Move sockets manifest types to //extensions.

extensions/common/api/sockets/sockets_manifest_permission_unittest.cc

 // 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/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[]=
+const char kUdpBindPermission[] =
     "{ \"udp\": { \"bind\": [\"127.0.0.1:3007\", \"a.com:80\"] } }";
 
-const char kUdpSendPermission[]=
+const char kUdpSendPermission[] =
     "{ \"udp\": { \"send\": [\"\", \"a.com:80\"] } }";
 
-const char kTcpConnectPermission[]=
+const char kTcpConnectPermission[] =
     "{ \"tcp\": { \"connect\": [\"127.0.0.1:80\", \"a.com:80\"] } }";
 
-const char kTcpServerListenPermission[]=
+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;
+  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) {
-  }
+      : 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 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;
+           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;
+           << "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) {
+  for (SocketsManifestPermission::SocketPermissionEntrySet::const_iterator it =
+           permission->entries().begin();
+       it != permission->entries().end();
+       ++it) {
     parsed_permissions.insert(
-        CheckFormatEntry(it->pattern().type,  it->GetHostPatternAsString()));
+        CheckFormatEntry(it->pattern().type, it->GetHostPatternAsString()));
   }
 
-  if (!std::equal(permissions.begin(), permissions.end(),
-      parsed_permissions.begin())) {
+  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) {
+  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) {
+  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);
+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());
 
@@ skipping 34 matching lines @@
       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\":\"\"}}",
+  EXPECT_TRUE(CheckFormat(
+      "{\"udp\":{\"send\":\"\"}}",
       CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "*:*")));
   EXPECT_TRUE(CheckFormat("{\"udp\":{\"send\":[]}}"));
-  EXPECT_TRUE(CheckFormat("{\"udp\":{\"send\":[\"\"]}}",
+  EXPECT_TRUE(CheckFormat(
+      "{\"udp\":{\"send\":[\"\"]}}",
       CheckFormatEntry(SocketPermissionRequest::UDP_SEND_TO, "*:*")));
-  EXPECT_TRUE(CheckFormat("{\"udp\":{\"send\":[\"a:80\", \"b:10\"]}}",
+  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\":\"\"}}",
+                  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\":{\"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\":\"\"}}",
+  EXPECT_TRUE(CheckFormat(
+      "{\"udp\":{\"multicastMembership\":\"\"}}",
       CheckFormatEntry(SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP, "")));
   EXPECT_TRUE(CheckFormat("{\"udp\":{\"multicastMembership\":[]}}"));
-  EXPECT_TRUE(CheckFormat("{\"udp\":{\"multicastMembership\":[\"\"]}}",
+  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("{\"tcp\":{\"connect\":\"\"}}",
+  EXPECT_TRUE(CheckFormat(
+      "{\"tcp\":{\"connect\":\"\"}}",
       CheckFormatEntry(SocketPermissionRequest::TCP_CONNECT, "*:*")));
   EXPECT_TRUE(CheckFormat("{\"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\"]}}",
+  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\":\"\"}}",
+  EXPECT_TRUE(CheckFormat(
+      "{\"tcpServer\":{\"listen\":\"\"}}",
       CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "*:*")));
   EXPECT_TRUE(CheckFormat("{\"tcpServer\":{\"listen\":[]}}"));
-  EXPECT_TRUE(CheckFormat("{\"tcpServer\":{\"listen\":[\"\"]}}",
+  EXPECT_TRUE(CheckFormat(
+      "{\"tcpServer\":{\"listen\":[\"\"]}}",
       CheckFormatEntry(SocketPermissionRequest::TCP_LISTEN, "*:*")));
-  EXPECT_TRUE(CheckFormat("{\"tcpServer\":{\"listen\":[\"a:80\", \"b:10\"]}}",
+  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\"]}"
+      "\"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));
 
@@ skipping 107 matching lines @@
       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