Support socket endpoint permissions for AppsV2 Socket API.

chrome/common/extensions/extension_unittest.cc

 // Copyright (c) 2012 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 "chrome/common/extensions/extension.h"
 
 #include "base/format_macros.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/command.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/permissions/api_permission.h"
 #include "chrome/common/extensions/permissions/permission_set.h"
+#include "chrome/common/extensions/permissions/socket_permission.h"
 #include "chrome/common/url_constants.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/mime_sniffer.h"
 #include "skia/ext/image_operations.h"
 #include "net/base/mock_host_resolver.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/png_codec.h"
 
+using extensions::APIPermission;
 using extensions::APIPermissionSet;
 using extensions::Extension;
 using extensions::PermissionSet;
+using extensions::SocketPermission;
+using extensions::SocketPermissionData;
 
 namespace keys = extension_manifest_keys;
 namespace values = extension_manifest_values;
 namespace errors = extension_manifest_errors;
 
 namespace {
 
 void CompareLists(const std::vector<std::string>& expected,
                   const std::vector<std::string>& actual) {
   ASSERT_EQ(expected.size(), actual.size());
@@ skipping 391 matching lines @@
   EXPECT_TRUE(extension->HasEffectiveAccessToAllHosts());
 
   extension = LoadManifest("effective_host_permissions", "all_hosts3.json");
   hosts = extension->GetEffectiveHostPermissions();
   EXPECT_FALSE(hosts.MatchesURL(GURL("http://test/")));
   EXPECT_TRUE(hosts.MatchesURL(GURL("https://test/")));
   EXPECT_TRUE(hosts.MatchesURL(GURL("http://www.google.com")));
   EXPECT_TRUE(extension->HasEffectiveAccessToAllHosts());
 }
 
+static bool CheckSocketPermission(scoped_refptr<Extension> extension,
+    SocketPermissionData::OperationType type,
+    const char* host,
+    int port) {
+  SocketPermission::CheckParam param(type, host, port);
+  return extension->CheckAPIPermissionWithDetail(
+      APIPermission::kSocket, &param);
+}
+
+TEST(ExtensionTest, SocketPermissions) {

[miket_OOO, 2012/08/06 21:04:06]

These are good because they're tests, but you can still do much more specific
unit tests at the individual class level. E.g., for the empty.json test, you can
test much more -- wildcards, invalid input, input that looks malicious
(NULL/empty, :, ******, \\\\\\\\\, \0\0\0\0\0\0\0\0, \"*8*0:, illegal Unicode,
nulls in the middle of strings, negative port numbers, 33-bit port numbers,
dotted quads with illegal characters in the middle, etc.) that would be too
cumbersome to test at this level. You don't need to create an extension, even an
empty one, to test all those cases.

[Peng, 2012/08/07 21:31:55]

I added some unitttest for it. Done

+  scoped_refptr<Extension> extension;
+  extension = LoadManifest("socket_permissions", "empty.json");
+  EXPECT_FALSE(CheckSocketPermission(
+        extension, SocketPermissionData::TCP_CONNECT, "www.example.com", 80));
+
+  extension = LoadManifest("socket_permissions", "socket1.json");
+  EXPECT_FALSE(CheckSocketPermission(
+        extension, SocketPermissionData::TCP_CONNECT, "www.example.com", 80));
+
+  extension = LoadManifest("socket_permissions", "socket2.json");
+  EXPECT_TRUE(CheckSocketPermission(
+        extension, SocketPermissionData::TCP_CONNECT, "www.example.com", 80));
+  EXPECT_FALSE(CheckSocketPermission(
+        extension, SocketPermissionData::UDP_BIND, "", 80));
+  EXPECT_TRUE(CheckSocketPermission(
+        extension, SocketPermissionData::UDP_BIND, "", 8888));
+
+  EXPECT_FALSE(CheckSocketPermission(
+        extension, SocketPermissionData::UDP_SEND_TO, "example.com", 1900));
+  EXPECT_TRUE(CheckSocketPermission(
+        extension, SocketPermissionData::UDP_SEND_TO, "239.255.255.250", 1900));
+}
+
 // Returns a copy of |source| resized to |size| x |size|.
 static SkBitmap ResizedCopy(const SkBitmap& source, int size) {
   return skia::ImageOperations::Resize(source,
                                        skia::ImageOperations::RESIZE_LANCZOS3,
                                        size,
                                        size);
 }
 
 static bool SizeEquals(const SkBitmap& bitmap, const gfx::Size& size) {
   return bitmap.width() == size.width() && bitmap.height() == size.height();
@@ skipping 654 matching lines @@
 }
 
 TEST(ExtensionTest, GetSyncTypeExtensionWithTwoPlugins) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL(),
                             Extension::INTERNAL, 2, FilePath()));
   if (extension)
     EXPECT_EQ(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 #endif // !defined(OS_CHROMEOS)