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/rect.h"
  19 #include "url/gurl.h"
  20
  21 // Tests that serialize/deserialize correctly understand each other
  22 TEST(IPCMessageTest, Serialize) {
  23   const char* serialize_cases[] = {
  24     "http://www.google.com/",
  25     "http://user:pass@host.com:888/foo;bar?baz#nop",
  26   };
  27
  28   for (size_t i = 0; i < arraysize(serialize_cases); i++) {
  29     GURL input(serialize_cases[i]);
  30     IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
  31     IPC::ParamTraits<GURL>::Write(&msg, input);
  32
  33     GURL output;
  34     PickleIterator iter(msg);
  35     EXPECT_TRUE(IPC::ParamTraits<GURL>::Read(&msg, &iter, &output));
  36
  37     // We want to test each component individually to make sure its range was
  38     // correctly serialized and deserialized, not just the spec.
  39     EXPECT_EQ(input.possibly_invalid_spec(), output.possibly_invalid_spec());
  40     EXPECT_EQ(input.is_valid(), output.is_valid());
  41     EXPECT_EQ(input.scheme(), output.scheme());
  42     EXPECT_EQ(input.username(), output.username());
  43     EXPECT_EQ(input.password(), output.password());
  44     EXPECT_EQ(input.host(), output.host());
  45     EXPECT_EQ(input.port(), output.port());
  46     EXPECT_EQ(input.path(), output.path());
  47     EXPECT_EQ(input.query(), output.query());
  48     EXPECT_EQ(input.ref(), output.ref());
  49   }
  50
  51   // Test an invalid GURL.
  52   {
  53     IPC::Message msg;
  54     msg.WriteString("#inva://idurl/");
  55     GURL output;
  56     PickleIterator iter(msg);
  57     EXPECT_FALSE(IPC::ParamTraits<GURL>::Read(&msg, &iter, &output));
  58   }
  59
  60   // Also test the corrupt case.
  61   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
  62   msg.WriteInt(99);
  63   GURL output;
  64   PickleIterator iter(msg);
  65   EXPECT_FALSE(IPC::ParamTraits<GURL>::Read(&msg, &iter, &output));
  66 }
  67
  68 // Tests std::pair serialization
  69 TEST(IPCMessageTest, Pair) {
  70   typedef std::pair<std::string, std::string> TestPair;
  71
  72   TestPair input("foo", "bar");
  73   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
  74   IPC::ParamTraits<TestPair>::Write(&msg, input);
  75
  76   TestPair output;
  77   PickleIterator iter(msg);
  78   EXPECT_TRUE(IPC::ParamTraits<TestPair>::Read(&msg, &iter, &output));
  79   EXPECT_EQ(output.first, "foo");
  80   EXPECT_EQ(output.second, "bar");
  81 }
  82
  83 // Tests bitmap serialization.
  84 TEST(IPCMessageTest, Bitmap) {
  85   SkBitmap bitmap;
  86
  87   bitmap.setConfig(SkBitmap::kARGB_8888_Config, 10, 5);
  88   bitmap.allocPixels();
  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.config(), output.config());
  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 }