Move sockets manifest types to //extensions.

chrome/common/extensions/api/sockets/sockets_manifest_permission_unittest.cc

Index: chrome/common/extensions/api/sockets/sockets_manifest_permission_unittest.cc
diff --git a/chrome/common/extensions/api/sockets/sockets_manifest_permission_unittest.cc b/chrome/common/extensions/api/sockets/sockets_manifest_permission_unittest.cc
deleted file mode 100644
index 9be7daa2c25e33d8923783108e4ff5dbabc73a7e..0000000000000000000000000000000000000000
--- a/chrome/common/extensions/api/sockets/sockets_manifest_permission_unittest.cc
+++ /dev/null
@@ -1,403 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include <set>
-
-#include "base/json/json_reader.h"
-#include "base/pickle.h"
-#include "base/values.h"
-#include "chrome/common/extensions/api/sockets/sockets_manifest_permission.h"
-#include "extensions/common/extension_messages.h"
-#include "extensions/common/manifest_constants.h"
-#include "ipc/ipc_message.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using content::SocketPermissionRequest;
-
-namespace extensions {
-
-namespace {
-
-const char kUdpBindPermission[]=
-    "{ \"udp\": { \"bind\": [\"127.0.0.1:3007\", \"a.com:80\"] } }";
-
-const char kUdpSendPermission[]=
-    "{ \"udp\": { \"send\": [\"\", \"a.com:80\"] } }";
-
-const char kTcpConnectPermission[]=
-    "{ \"tcp\": { \"connect\": [\"127.0.0.1:80\", \"a.com:80\"] } }";
-
-const char kTcpServerListenPermission[]=
-    "{ \"tcpServer\": { \"listen\": [\"127.0.0.1:80\", \"a.com:80\"] } }";
-
-static void AssertEmptyPermission(const SocketsManifestPermission* permission) {
-  EXPECT_TRUE(permission);
-  EXPECT_EQ(std::string(extensions::manifest_keys::kSockets), permission->id());
-  EXPECT_EQ(permission->id(), permission->name());
-  EXPECT_FALSE(permission->HasMessages());
-  EXPECT_EQ(0u, permission->entries().size());
-}
-
-static scoped_ptr<base::Value> ParsePermissionJSON(const std::string& json) {
-  scoped_ptr<base::Value> result(base::JSONReader::Read(json));
-  EXPECT_TRUE(result) << "Invalid JSON string: " << json;
-  return result.Pass();
-}
-
-static scoped_ptr<SocketsManifestPermission> PermissionFromValue(
-    const base::Value& value) {
-  base::string16 error16;
-  scoped_ptr<SocketsManifestPermission> permission(
-      SocketsManifestPermission::FromValue(value, &error16));
-  EXPECT_TRUE(permission)
-      << "Error parsing Value into permission: " << error16;
-  return permission.Pass();
-}
-
-static scoped_ptr<SocketsManifestPermission> PermissionFromJSON(
-    const std::string& json) {
-  scoped_ptr<base::Value> value(ParsePermissionJSON(json));
-  return PermissionFromValue(*value);
-}
-
-struct CheckFormatEntry {
-  CheckFormatEntry(SocketPermissionRequest::OperationType operation_type,
-                   std::string host_pattern)
-      : operation_type(operation_type),
-        host_pattern(host_pattern) {
-  }
-
-  // operators <, == are needed by container std::set and algorithms
-  // std::set_includes and std::set_differences.
-  bool operator<(const CheckFormatEntry& rhs) const {
-    if (operation_type == rhs.operation_type)
-      return  host_pattern < rhs.host_pattern;
-
-    return operation_type < rhs.operation_type;
-  }
-
-  bool operator==(const CheckFormatEntry& rhs) const {
-    return operation_type == rhs.operation_type &&
-      host_pattern == rhs.host_pattern;
-  }
-
-  SocketPermissionRequest::OperationType operation_type;
-  std::string host_pattern;
-};
-
-static testing::AssertionResult CheckFormat(
-    std::multiset<CheckFormatEntry> permissions,
-    const std::string& json) {
-  scoped_ptr<SocketsManifestPermission> permission(PermissionFromJSON(json));
-  if (!permission)
-    return testing::AssertionFailure() << "Invalid permission " << json;
-
-  if (permissions.size() != permission->entries().size()) {
-    return testing::AssertionFailure()
-        << "Incorrect # of entries in json: " << json;
-  }
-
-  // Note: We use multiset because SocketsManifestPermission does not have to
-  // store entries in the order found in the json message.
-  std::multiset<CheckFormatEntry> parsed_permissions;
-  for (SocketsManifestPermission::SocketPermissionEntrySet::const_iterator
-      it = permission->entries().begin(); it != permission->entries().end();
-      ++it) {
-    parsed_permissions.insert(
-        CheckFormatEntry(it->pattern().type,  it->GetHostPatternAsString()));
-  }
-
-  if (!std::equal(permissions.begin(), permissions.end(),
-      parsed_permissions.begin())) {
-    return testing::AssertionFailure() << "Incorrect socket operations.";
-  }
-  return testing::AssertionSuccess();
-}
-
-static testing::AssertionResult CheckFormat(const std::string& json) {
-  return CheckFormat(std::multiset<CheckFormatEntry>(), json);
-}
-
-static testing::AssertionResult CheckFormat(
-    const std::string& json,
-    const CheckFormatEntry& op1) {
-  CheckFormatEntry entries[] = {
-    op1
-  };
-  return CheckFormat(std::multiset<CheckFormatEntry>(
-      entries, entries + arraysize(entries)), json);
-}
-
-static testing::AssertionResult CheckFormat(
-    const std::string& json,
-    const CheckFormatEntry& op1,
-    const CheckFormatEntry& op2) {
-  CheckFormatEntry entries[] = {
-    op1, op2
-  };
-  return CheckFormat(std::multiset<CheckFormatEntry>(
-      entries, entries + arraysize(entries)), json);
-}
-
-static testing::AssertionResult CheckFormat(
-    const std::string& json,
-    const CheckFormatEntry& op1,
-    const CheckFormatEntry& op2,
-    const CheckFormatEntry& op3,
-    const CheckFormatEntry& op4,
-    const CheckFormatEntry& op5,
-    const CheckFormatEntry& op6,
-    const CheckFormatEntry& op7,
-    const CheckFormatEntry& op8,
-    const CheckFormatEntry& op9) {
-  CheckFormatEntry entries[] = {
-    op1, op2, op3, op4, op5, op6, op7, op8, op9
-  };
-  return CheckFormat(std::multiset<CheckFormatEntry>(
-      entries, entries + arraysize(entries)), json);
-}
-
-}  // namespace
-
-TEST(SocketsManifestPermissionTest, Empty) {
-  // Construction
-  scoped_ptr<SocketsManifestPermission> permission(
-      new SocketsManifestPermission());
-  AssertEmptyPermission(permission.get());
-
-  // Clone()/Equal()
-  scoped_ptr<SocketsManifestPermission> clone(
-      static_cast<SocketsManifestPermission*>(permission->Clone()));
-  AssertEmptyPermission(clone.get());
-
-  EXPECT_TRUE(permission->Equal(clone.get()));
-
-  // ToValue()/FromValue()
-  scoped_ptr<const base::Value> value(permission->ToValue());
-  EXPECT_TRUE(value.get());
-
-  scoped_ptr<SocketsManifestPermission> permission2(
-      new SocketsManifestPermission());
-  EXPECT_TRUE(permission2->FromValue(value.get()));
-  AssertEmptyPermission(permission2.get());
-
-  // Union/Diff/Intersection
-  scoped_ptr<SocketsManifestPermission> diff_perm(
-      static_cast<SocketsManifestPermission*>(permission->Diff(clone.get())));
-  AssertEmptyPermission(diff_perm.get());
-
-  scoped_ptr<SocketsManifestPermission> union_perm(
-      static_cast<SocketsManifestPermission*>(permission->Union(clone.get())));
-  AssertEmptyPermission(union_perm.get());
-
-  scoped_ptr<SocketsManifestPermission> intersect_perm(
-      static_cast<SocketsManifestPermission*>(
-          permission->Intersect(clone.get())));
-  AssertEmptyPermission(intersect_perm.get());
-
-  // IPC
-  scoped_ptr<SocketsManifestPermission> ipc_perm(
-      new SocketsManifestPermission());
-  scoped_ptr<SocketsManifestPermission> ipc_perm2(
-      new SocketsManifestPermission());
-
-  IPC::Message m;
-  ipc_perm->Write(&m);
-  PickleIterator iter(m);
-  EXPECT_TRUE(ipc_perm2->Read(&m, &iter));
-  AssertEmptyPermission(ipc_perm2.get());
-}
-
-TEST(SocketsManifestPermissionTest, JSONFormats) {
-  EXPECT_TRUE(CheckFormat("{\"udp\":{\"send\":\"\"}}",
-      CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "*:*")));
-  EXPECT_TRUE(CheckFormat("{\"udp\":{\"send\":[]}}"));
-  EXPECT_TRUE(CheckFormat("{\"udp\":{\"send\":[\"\"]}}",
-      CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "*:*")));
-  EXPECT_TRUE(CheckFormat("{\"udp\":{\"send\":[\"a:80\", \"b:10\"]}}",
-      CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "a:80"),
-      CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "b:10")));
-
-  EXPECT_TRUE(CheckFormat("{\"udp\":{\"bind\":\"\"}}",
-      CheckFormatEntry(SocketPermissionRequest::UDP_BIND, "*:*")));
-  EXPECT_TRUE(CheckFormat("{\"udp\":{\"bind\":[]}}"));
-  EXPECT_TRUE(CheckFormat("{\"udp\":{\"bind\":[\"\"]}}",
-      CheckFormatEntry(SocketPermissionRequest::UDP_BIND, "*:*")));
-  EXPECT_TRUE(CheckFormat("{\"udp\":{\"bind\":[\"a:80\", \"b:10\"]}}",
-      CheckFormatEntry(SocketPermissionRequest::UDP_BIND, "a:80"),
-      CheckFormatEntry(SocketPermissionRequest::UDP_BIND, "b:10")));
-
-  EXPECT_TRUE(CheckFormat("{\"udp\":{\"multicastMembership\":\"\"}}",
-      CheckFormatEntry(SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP, "")));
-  EXPECT_TRUE(CheckFormat("{\"udp\":{\"multicastMembership\":[]}}"));
-  EXPECT_TRUE(CheckFormat("{\"udp\":{\"multicastMembership\":[\"\"]}}",
-      CheckFormatEntry(SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP, "")));
-  EXPECT_TRUE(CheckFormat("{\"udp\":{\"multicastMembership\":[\"\", \"\"]}}",
-      CheckFormatEntry(SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP, "")));
-
-  EXPECT_TRUE(CheckFormat("{\"tcp\":{\"connect\":\"\"}}",
-      CheckFormatEntry(SocketPermissionRequest::TCP_CONNECT, "*:*")));
-  EXPECT_TRUE(CheckFormat("{\"tcp\":{\"connect\":[]}}"));
-  EXPECT_TRUE(CheckFormat("{\"tcp\":{\"connect\":[\"\"]}}",
-      CheckFormatEntry(SocketPermissionRequest::TCP_CONNECT, "*:*")));
-  EXPECT_TRUE(CheckFormat("{\"tcp\":{\"connect\":[\"a:80\", \"b:10\"]}}",
-      CheckFormatEntry(SocketPermissionRequest::TCP_CONNECT, "a:80"),
-      CheckFormatEntry(SocketPermissionRequest::TCP_CONNECT, "b:10")));
-
-  EXPECT_TRUE(CheckFormat("{\"tcpServer\":{\"listen\":\"\"}}",
-      CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "*:*")));
-  EXPECT_TRUE(CheckFormat("{\"tcpServer\":{\"listen\":[]}}"));
-  EXPECT_TRUE(CheckFormat("{\"tcpServer\":{\"listen\":[\"\"]}}",
-      CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "*:*")));
-  EXPECT_TRUE(CheckFormat("{\"tcpServer\":{\"listen\":[\"a:80\", \"b:10\"]}}",
-      CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "a:80"),
-      CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "b:10")));
-
-  EXPECT_TRUE(CheckFormat(
-      "{"
-        "\"udp\":{"
-          "\"send\":[\"a:80\", \"b:10\"],"
-          "\"bind\":[\"a:80\", \"b:10\"],"
-          "\"multicastMembership\":\"\""
-        "},"
-        "\"tcp\":{\"connect\":[\"a:80\", \"b:10\"]},"
-        "\"tcpServer\":{\"listen\":[\"a:80\", \"b:10\"]}"
-      "}",
-      CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "a:80"),
-      CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "b:10"),
-      CheckFormatEntry(SocketPermissionRequest::UDP_BIND, "a:80"),
-      CheckFormatEntry(SocketPermissionRequest::UDP_BIND, "b:10"),
-      CheckFormatEntry(SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP, ""),
-      CheckFormatEntry(SocketPermissionRequest::TCP_CONNECT, "a:80"),
-      CheckFormatEntry(SocketPermissionRequest::TCP_CONNECT, "b:10"),
-      CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "a:80"),
-      CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "b:10")));
-
-}
-
-TEST(SocketsManifestPermissionTest, FromToValue) {
-  scoped_ptr<base::Value> udp_send(ParsePermissionJSON(kUdpBindPermission));
-  scoped_ptr<base::Value> udp_bind(ParsePermissionJSON(kUdpSendPermission));
-  scoped_ptr<base::Value> tcp_connect(
-      ParsePermissionJSON(kTcpConnectPermission));
-  scoped_ptr<base::Value> tcp_server_listen(
-      ParsePermissionJSON(kTcpServerListenPermission));
-
-  // FromValue()
-  scoped_ptr<SocketsManifestPermission> permission1(
-      new SocketsManifestPermission());
-  EXPECT_TRUE(permission1->FromValue(udp_send.get()));
-  EXPECT_EQ(2u, permission1->entries().size());
-
-  scoped_ptr<SocketsManifestPermission> permission2(
-      new SocketsManifestPermission());
-  EXPECT_TRUE(permission2->FromValue(udp_bind.get()));
-  EXPECT_EQ(2u, permission2->entries().size());
-
-  scoped_ptr<SocketsManifestPermission> permission3(
-      new SocketsManifestPermission());
-  EXPECT_TRUE(permission3->FromValue(tcp_connect.get()));
-  EXPECT_EQ(2u, permission3->entries().size());
-
-  scoped_ptr<SocketsManifestPermission> permission4(
-      new SocketsManifestPermission());
-  EXPECT_TRUE(permission4->FromValue(tcp_server_listen.get()));
-  EXPECT_EQ(2u, permission4->entries().size());
-
-  // ToValue()
-  scoped_ptr<base::Value> value1 = permission1->ToValue();
-  EXPECT_TRUE(value1);
-  scoped_ptr<SocketsManifestPermission> permission1_1(
-      new SocketsManifestPermission());
-  EXPECT_TRUE(permission1_1->FromValue(value1.get()));
-  EXPECT_TRUE(permission1->Equal(permission1_1.get()));
-
-  scoped_ptr<base::Value> value2 = permission2->ToValue();
-  EXPECT_TRUE(value2);
-  scoped_ptr<SocketsManifestPermission> permission2_1(
-      new SocketsManifestPermission());
-  EXPECT_TRUE(permission2_1->FromValue(value2.get()));
-  EXPECT_TRUE(permission2->Equal(permission2_1.get()));
-
-  scoped_ptr<base::Value> value3 = permission3->ToValue();
-  EXPECT_TRUE(value3);
-  scoped_ptr<SocketsManifestPermission> permission3_1(
-      new SocketsManifestPermission());
-  EXPECT_TRUE(permission3_1->FromValue(value3.get()));
-  EXPECT_TRUE(permission3->Equal(permission3_1.get()));
-
-  scoped_ptr<base::Value> value4 = permission4->ToValue();
-  EXPECT_TRUE(value4);
-  scoped_ptr<SocketsManifestPermission> permission4_1(
-      new SocketsManifestPermission());
-  EXPECT_TRUE(permission4_1->FromValue(value4.get()));
-  EXPECT_TRUE(permission4->Equal(permission4_1.get()));
-}
-
-TEST(SocketsManifestPermissionTest, SetOperations) {
-  scoped_ptr<SocketsManifestPermission> permission1(
-      PermissionFromJSON(kUdpBindPermission));
-  scoped_ptr<SocketsManifestPermission> permission2(
-      PermissionFromJSON(kUdpSendPermission));
-  scoped_ptr<SocketsManifestPermission> permission3(
-      PermissionFromJSON(kTcpConnectPermission));
-  scoped_ptr<SocketsManifestPermission> permission4(
-      PermissionFromJSON(kTcpServerListenPermission));
-
-  // Union
-  scoped_ptr<SocketsManifestPermission> union_perm(
-      static_cast<SocketsManifestPermission*>(
-          permission1->Union(permission2.get())));
-  EXPECT_TRUE(union_perm);
-  EXPECT_EQ(4u, union_perm->entries().size());
-
-  EXPECT_TRUE(union_perm->Contains(permission1.get()));
-  EXPECT_TRUE(union_perm->Contains(permission2.get()));
-  EXPECT_FALSE(union_perm->Contains(permission3.get()));
-  EXPECT_FALSE(union_perm->Contains(permission4.get()));
-
-  // Diff
-  scoped_ptr<SocketsManifestPermission> diff_perm1(
-      static_cast<SocketsManifestPermission*>(
-          permission1->Diff(permission2.get())));
-  EXPECT_TRUE(diff_perm1);
-  EXPECT_EQ(2u, diff_perm1->entries().size());
-
-  EXPECT_TRUE(permission1->Equal(diff_perm1.get()));
-  EXPECT_TRUE(diff_perm1->Equal(permission1.get()));
-
-  scoped_ptr<SocketsManifestPermission> diff_perm2(
-      static_cast<SocketsManifestPermission*>(
-          permission1->Diff(union_perm.get())));
-  EXPECT_TRUE(diff_perm2);
-  AssertEmptyPermission(diff_perm2.get());
-
-  // Intersection
-  scoped_ptr<SocketsManifestPermission> intersect_perm1(
-      static_cast<SocketsManifestPermission*>(
-          union_perm->Intersect(permission1.get())));
-  EXPECT_TRUE(intersect_perm1);
-  EXPECT_EQ(2u, intersect_perm1->entries().size());
-
-  EXPECT_TRUE(permission1->Equal(intersect_perm1.get()));
-  EXPECT_TRUE(intersect_perm1->Equal(permission1.get()));
-}
-
-TEST(SocketsManifestPermissionTest, IPC) {
-  scoped_ptr<SocketsManifestPermission> permission(
-      PermissionFromJSON(kUdpBindPermission));
-
-  scoped_ptr<SocketsManifestPermission> ipc_perm(
-      static_cast<SocketsManifestPermission*>(permission->Clone()));
-  scoped_ptr<SocketsManifestPermission> ipc_perm2(
-      new SocketsManifestPermission());
-
-  IPC::Message m;
-  ipc_perm->Write(&m);
-  PickleIterator iter(m);
-  EXPECT_TRUE(ipc_perm2->Read(&m, &iter));
-  EXPECT_TRUE(permission->Equal(ipc_perm2.get()));
-}
-
-}  // namespace extensions