content/common/common_param_traits_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string.h>
   6 #include <utility>
   7
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/values.h"
  10 #include "content/public/common/common_param_traits.h"
  11 #include "ipc/ipc_message.h"
  12 #include "ipc/ipc_message_utils.h"
  13 #include "net/base/host_port_pair.h"
  14 #include "printing/backend/print_backend.h"
  15 #include "printing/page_range.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17 #include "third_party/skia/include/core/SkBitmap.h"
  18 #include "ui/gfx/ipc/gfx_param_traits.h"
  19 #include "ui/gfx/rect.h"
  20 #include "url/gurl.h"
  21
  22 // Tests that serialize/deserialize correctly understand each other
  23 TEST(IPCMessageTest, Serialize) {
  24   const char* serialize_cases[] = {
  25     "http://www.google.com/",
  26     "http://user:pass@host.com:888/foo;bar?baz#nop",
  27   };
  28
  29   for (size_t i = 0; i < arraysize(serialize_cases); i++) {
  30     GURL input(serialize_cases[i]);
  31     IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
  32     IPC::ParamTraits<GURL>::Write(&msg, input);
  33
  34     GURL output;
  35     PickleIterator iter(msg);
  36     EXPECT_TRUE(IPC::ParamTraits<GURL>::Read(&msg, &iter, &output));
  37
  38     // We want to test each component individually to make sure its range was
  39     // correctly serialized and deserialized, not just the spec.
  40     EXPECT_EQ(input.possibly_invalid_spec(), output.possibly_invalid_spec());
  41     EXPECT_EQ(input.is_valid(), output.is_valid());
  42     EXPECT_EQ(input.scheme(), output.scheme());
  43     EXPECT_EQ(input.username(), output.username());
  44     EXPECT_EQ(input.password(), output.password());
  45     EXPECT_EQ(input.host(), output.host());
  46     EXPECT_EQ(input.port(), output.port());
  47     EXPECT_EQ(input.path(), output.path());
  48     EXPECT_EQ(input.query(), output.query());
  49     EXPECT_EQ(input.ref(), output.ref());
  50   }
  51
  52   // Test an invalid GURL.
  53   {
  54     IPC::Message msg;
  55     msg.WriteString("#inva://idurl/");
  56     GURL output;
  57     PickleIterator iter(msg);
  58     EXPECT_FALSE(IPC::ParamTraits<GURL>::Read(&msg, &iter, &output));
  59   }
  60
  61   // Also test the corrupt case.
  62   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
  63   msg.WriteInt(99);
  64   GURL output;
  65   PickleIterator iter(msg);
  66   EXPECT_FALSE(IPC::ParamTraits<GURL>::Read(&msg, &iter, &output));
  67 }
  68
  69 // Tests std::pair serialization
  70 TEST(IPCMessageTest, Pair) {
  71   typedef std::pair<std::string, std::string> TestPair;
  72
  73   TestPair input("foo", "bar");
  74   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
  75   IPC::ParamTraits<TestPair>::Write(&msg, input);
  76
  77   TestPair output;
  78   PickleIterator iter(msg);
  79   EXPECT_TRUE(IPC::ParamTraits<TestPair>::Read(&msg, &iter, &output));
  80   EXPECT_EQ(output.first, "foo");
  81   EXPECT_EQ(output.second, "bar");
  82 }
  83
  84 // Tests bitmap serialization.
  85 TEST(IPCMessageTest, Bitmap) {
  86   SkBitmap bitmap;
  87
  88   bitmap.allocN32Pixels(10, 5);
  89   memset(bitmap.getPixels(), 'A', bitmap.getSize());
  90
  91   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
  92   IPC::ParamTraits<SkBitmap>::Write(&msg, bitmap);
  93
  94   SkBitmap output;
  95   PickleIterator iter(msg);
  96   EXPECT_TRUE(IPC::ParamTraits<SkBitmap>::Read(&msg, &iter, &output));
  97
  98   EXPECT_EQ(bitmap.colorType(), output.colorType());
  99   EXPECT_EQ(bitmap.width(), output.width());
 100   EXPECT_EQ(bitmap.height(), output.height());
 101   EXPECT_EQ(bitmap.rowBytes(), output.rowBytes());
 102   EXPECT_EQ(bitmap.getSize(), output.getSize());
 103   EXPECT_EQ(memcmp(bitmap.getPixels(), output.getPixels(), bitmap.getSize()),
 104             0);
 105
 106   // Also test the corrupt case.
 107   IPC::Message bad_msg(1, 2, IPC::Message::PRIORITY_NORMAL);
 108   // Copy the first message block over to |bad_msg|.
 109   const char* fixed_data;
 110   int fixed_data_size;
 111   iter = PickleIterator(msg);
 112   EXPECT_TRUE(msg.ReadData(&iter, &fixed_data, &fixed_data_size));
 113   bad_msg.WriteData(fixed_data, fixed_data_size);
 114   // Add some bogus pixel data.
 115   const size_t bogus_pixels_size = bitmap.getSize() * 2;
 116   scoped_ptr<char[]> bogus_pixels(new char[bogus_pixels_size]);
 117   memset(bogus_pixels.get(), 'B', bogus_pixels_size);
 118   bad_msg.WriteData(bogus_pixels.get(), bogus_pixels_size);
 119   // Make sure we don't read out the bitmap!
 120   SkBitmap bad_output;
 121   iter = PickleIterator(bad_msg);
 122   EXPECT_FALSE(IPC::ParamTraits<SkBitmap>::Read(&bad_msg, &iter, &bad_output));
 123 }
 124
 125 TEST(IPCMessageTest, ListValue) {
 126   base::ListValue input;
 127   input.Set(0, new base::FundamentalValue(42.42));
 128   input.Set(1, new base::StringValue("forty"));
 129   input.Set(2, base::Value::CreateNullValue());
 130
 131   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
 132   IPC::WriteParam(&msg, input);
 133
 134   base::ListValue output;
 135   PickleIterator iter(msg);
 136   EXPECT_TRUE(IPC::ReadParam(&msg, &iter, &output));
 137
 138   EXPECT_TRUE(input.Equals(&output));
 139
 140   // Also test the corrupt case.
 141   IPC::Message bad_msg(1, 2, IPC::Message::PRIORITY_NORMAL);
 142   bad_msg.WriteInt(99);
 143   iter = PickleIterator(bad_msg);
 144   EXPECT_FALSE(IPC::ReadParam(&bad_msg, &iter, &output));
 145 }
 146
 147 TEST(IPCMessageTest, DictionaryValue) {
 148   base::DictionaryValue input;
 149   input.Set("null", base::Value::CreateNullValue());
 150   input.Set("bool", new base::FundamentalValue(true));
 151   input.Set("int", new base::FundamentalValue(42));
 152
 153   scoped_ptr<base::DictionaryValue> subdict(new base::DictionaryValue());
 154   subdict->Set("str", new base::StringValue("forty two"));
 155   subdict->Set("bool", new base::FundamentalValue(false));
 156
 157   scoped_ptr<base::ListValue> sublist(new base::ListValue());
 158   sublist->Set(0, new base::FundamentalValue(42.42));
 159   sublist->Set(1, new base::StringValue("forty"));
 160   sublist->Set(2, new base::StringValue("two"));
 161   subdict->Set("list", sublist.release());
 162
 163   input.Set("dict", subdict.release());
 164
 165   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
 166   IPC::WriteParam(&msg, input);
 167
 168   base::DictionaryValue output;
 169   PickleIterator iter(msg);
 170   EXPECT_TRUE(IPC::ReadParam(&msg, &iter, &output));
 171
 172   EXPECT_TRUE(input.Equals(&output));
 173
 174   // Also test the corrupt case.
 175   IPC::Message bad_msg(1, 2, IPC::Message::PRIORITY_NORMAL);
 176   bad_msg.WriteInt(99);
 177   iter = PickleIterator(bad_msg);
 178   EXPECT_FALSE(IPC::ReadParam(&bad_msg, &iter, &output));
 179 }
 180
 181 // Tests net::HostPortPair serialization
 182 TEST(IPCMessageTest, HostPortPair) {
 183   net::HostPortPair input("host.com", 12345);
 184
 185   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
 186   IPC::ParamTraits<net::HostPortPair>::Write(&msg, input);
 187
 188   net::HostPortPair output;
 189   PickleIterator iter(msg);
 190   EXPECT_TRUE(IPC::ParamTraits<net::HostPortPair>::Read(&msg, &iter, &output));
 191   EXPECT_EQ(input.host(), output.host());
 192   EXPECT_EQ(input.port(), output.port());
 193 }