code.vuplus.com Git - vuplus_webkit/blob - Source/WebKit2/Platform/CoreIPC/ArgumentCoders.cpp

   1 /*
   2  * Copyright (C) 2011 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "ArgumentCoders.h"
  28
  29 #include <wtf/text/CString.h>
  30 #include <wtf/text/WTFString.h>
  31
  32 namespace CoreIPC {
  33
  34 void ArgumentCoder<AtomicString>::encode(ArgumentEncoder* encoder, const AtomicString& atomicString)
  35 {
  36     encoder->encode(atomicString.string());
  37 }
  38
  39 bool ArgumentCoder<AtomicString>::decode(ArgumentDecoder* decoder, AtomicString& atomicString)
  40 {
  41     String string;
  42     if (!decoder->decode(string))
  43         return false;
  44
  45     atomicString = string;
  46     return true;
  47 }
  48
  49 void ArgumentCoder<CString>::encode(ArgumentEncoder* encoder, const CString& string)
  50 {
  51     // Special case the null string.
  52     if (string.isNull()) {
  53         encoder->encodeUInt32(std::numeric_limits<uint32_t>::max());
  54         return;
  55     }
  56
  57     uint32_t length = string.length();
  58     encoder->encode(length);
  59     encoder->encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.data()), length, 1);
  60 }
  61
  62 bool ArgumentCoder<CString>::decode(ArgumentDecoder* decoder, CString& result)
  63 {
  64     uint32_t length;
  65     if (!decoder->decode(length))
  66         return false;
  67
  68     if (length == std::numeric_limits<uint32_t>::max()) {
  69         // This is the null string.
  70         result = CString();
  71         return true;
  72     }
  73
  74     // Before allocating the string, make sure that the decoder buffer is big enough.
  75     if (!decoder->bufferIsLargeEnoughToContain<char>(length)) {
  76         decoder->markInvalid();
  77         return false;
  78     }
  79
  80     char* buffer;
  81     CString string = CString::newUninitialized(length, buffer);
  82     if (!decoder->decodeFixedLengthData(reinterpret_cast<uint8_t*>(buffer), length, 1))
  83         return false;
  84
  85     result = string;
  86     return true;
  87 }
  88
  89
  90 void ArgumentCoder<String>::encode(ArgumentEncoder* encoder, const String& string)
  91 {
  92     // Special case the null string.
  93     if (string.isNull()) {
  94         encoder->encodeUInt32(std::numeric_limits<uint32_t>::max());
  95         return;
  96     }
  97
  98     uint32_t length = string.length();
  99     encoder->encode(length);
 100     encoder->encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.characters()), length * sizeof(UChar), __alignof(UChar));
 101 }
 102
 103 bool ArgumentCoder<String>::decode(ArgumentDecoder* decoder, String& result)
 104 {
 105     uint32_t length;
 106     if (!decoder->decode(length))
 107         return false;
 108
 109     if (length == std::numeric_limits<uint32_t>::max()) {
 110         // This is the null string.
 111         result = String();
 112         return true;
 113     }
 114
 115     // Before allocating the string, make sure that the decoder buffer is big enough.
 116     if (!decoder->bufferIsLargeEnoughToContain<UChar>(length)) {
 117         decoder->markInvalid();
 118         return false;
 119     }
 120
 121     UChar* buffer;
 122     String string = String::createUninitialized(length, buffer);
 123     if (!decoder->decodeFixedLengthData(reinterpret_cast<uint8_t*>(buffer), length * sizeof(UChar), __alignof(UChar)))
 124         return false;
 125
 126     result = string;
 127     return true;
 128 }
 129
 130 } // namespace CoreIPC