Move ScriptBadge, ActionInfo out of Extension; preparation for BrowserAction

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/file_path.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/common/extensions/api/extension_action/action_info.h"
 #include "chrome/common/extensions/command.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/features/feature.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/extensions/permissions/usb_device_permission.h"
 #include "chrome/common/url_constants.h"
 #include "extensions/common/error_utils.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/mime_sniffer.h"
 #include "net/base/mock_host_resolver.h"
 #include "skia/ext/image_operations.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/png_codec.h"
 
 using content::SocketPermissionRequest;
-using extensions::APIPermission;
-using extensions::APIPermissionSet;
-using extensions::ErrorUtils;
-using extensions::Extension;
-using extensions::Feature;
-using extensions::PermissionSet;
-using extensions::SocketPermission;
-using extensions::URLPatternSet;
-using extensions::UsbDevicePermission;
 
 namespace keys = extension_manifest_keys;
 namespace values = extension_manifest_values;
 namespace errors = extension_manifest_errors;
 
+namespace extensions {
 namespace {
 
 scoped_refptr<Extension> LoadManifestUnchecked(
     const std::string& dir,
     const std::string& test_file,
     Extension::Location location,
     int extra_flags,
     std::string* error) {
   FilePath path;
   PathService::Get(chrome::DIR_TEST_DATA, &path);
@@ skipping 34 matching lines @@
                                              const std::string& test_file) {
   return LoadManifest(dir, test_file, Extension::NO_FLAGS);
 }
 
 static scoped_refptr<Extension> LoadManifestStrict(
     const std::string& dir,
     const std::string& test_file) {
   return LoadManifest(dir, test_file, Extension::NO_FLAGS);
 }
 
-static scoped_ptr<Extension::ActionInfo> LoadAction(
+static scoped_ptr<ActionInfo> LoadAction(
     const std::string& manifest) {
   scoped_refptr<Extension> extension = LoadManifest("page_action",
       manifest);
   EXPECT_TRUE(extension->page_action_info());
   if (extension->page_action_info()) {
-    return make_scoped_ptr(new Extension::ActionInfo(
+    return make_scoped_ptr(new ActionInfo(
         *extension->page_action_info()));
   }
   ADD_FAILURE() << "Expected manifest in " << manifest
                 << " to include a page_action section.";
-  return scoped_ptr<Extension::ActionInfo>();
+  return scoped_ptr<ActionInfo>();
 }
 
 static void LoadActionAndExpectError(const std::string& manifest,
                                      const std::string& expected_error) {
   std::string error;
   scoped_refptr<Extension> extension = LoadManifestUnchecked("page_action",
       manifest, Extension::INTERNAL, Extension::NO_FLAGS, &error);
   EXPECT_FALSE(extension);
   EXPECT_EQ(expected_error, error);
 }
@@ skipping 81 matching lines @@
                                                      &err, &warnings));
   EXPECT_EQ(0U, warnings.size());
 
   EXPECT_EQ(extension->path().AppendASCII("test.html").value(),
             extension->GetResource("test.html").GetFilePath().value());
   EXPECT_EQ(extension->path().AppendASCII("test.js").value(),
             extension->GetResource("test.js").GetFilePath().value());
 }
 
 TEST(ExtensionTest, LoadPageActionHelper) {
-  scoped_ptr<Extension::ActionInfo> action;
+  scoped_ptr<ActionInfo> action;
 
   // First try with an empty dictionary.
   action = LoadAction("page_action_empty.json");
   ASSERT_TRUE(action != NULL);
 
   // Now setup some values to use in the action.
   const std::string id("MyExtensionActionId");
   const std::string name("MyExtensionActionName");
   std::string img1("image1.png");
 
@@ skipping 521 matching lines @@
   EXPECT_FALSE(extension->from_webstore());
 }
 
 TEST(ExtensionTest, BrowserActionSynthesizesCommand) {
   scoped_refptr<Extension> extension;
 
   extension = LoadManifest("api_test/browser_action/synthesized",
                            "manifest.json");
   // An extension with a browser action but no extension command specified
   // should get a command assigned to it.
-  const extensions::Command* command = extension->browser_action_command();
+  const Command* command = extension->browser_action_command();
   ASSERT_TRUE(command != NULL);
   ASSERT_EQ(ui::VKEY_UNKNOWN, command->accelerator().key_code());
 }
 
 // Base class for testing the CanExecuteScriptOnPage and CanCaptureVisiblePage
 // methods of Extension for extensions with various permissions.
 class ExtensionScriptAndCaptureVisibleTest : public testing::Test {
  protected:
   ExtensionScriptAndCaptureVisibleTest()
       : http_url("http://www.google.com"),
@@ skipping 517 matching lines @@
 
 TEST(ExtensionTest, GetSyncTypeExtensionWithTwoPlugins) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL(),
                             Extension::INTERNAL, 2, FilePath(),
                             Extension::NO_FLAGS));
   if (extension)
     EXPECT_EQ(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 #endif // !defined(OS_CHROMEOS)
+
+}  // namespace extensions