Move Extension Location and Type enums to Manifest, and move InstallWarning to its own file.

chrome/browser/sync/test/integration/sync_extension_helper.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/browser/sync/test/integration/sync_extension_helper.h"
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/pending_extension_info.h"
 #include "chrome/browser/extensions/pending_extension_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/test/integration/sync_datatype_helper.h"
 #include "chrome/browser/sync/test/integration/sync_test.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "sync/api/string_ordinal.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using extensions::Extension;
+using extensions::Manifest;
 
 SyncExtensionHelper::ExtensionState::ExtensionState()
     : enabled_state(ENABLED), incognito_enabled(false) {}
 
 SyncExtensionHelper::ExtensionState::~ExtensionState() {}
 
 bool SyncExtensionHelper::ExtensionState::Equals(
     const SyncExtensionHelper::ExtensionState &other) const {
   return ((enabled_state == other.enabled_state) &&
           (incognito_enabled == other.incognito_enabled));
@@ skipping 23 matching lines @@
 
   for (int i = 0; i < test->num_clients(); ++i) {
     SetupProfile(test->GetProfile(i));
   }
   SetupProfile(test->verifier());
 
   setup_completed_ = true;
 }
 
 std::string SyncExtensionHelper::InstallExtension(
-    Profile* profile, const std::string& name, Extension::Type type) {
+    Profile* profile, const std::string& name, Manifest::Type type) {
   scoped_refptr<Extension> extension = GetExtension(profile, name, type);
   if (!extension.get()) {
     NOTREACHED() << "Could not install extension " << name;
     return "";
   }
   profile->GetExtensionService()->OnExtensionInstalled(
       extension, syncer::StringOrdinal(), false /* no requirement errors */,
       false /* don't wait for idle to install */);
   return extension->id();
 }
@@ skipping 181 matching lines @@
   std::string pem;
   EXPECT_TRUE(Extension::ProducePEM(name, &pem) &&
               Extension::FormatPEMForFileOutput(pem, &public_key,
                                                 true /* is_public */));
   return public_key;
 }
 
 // TODO(akalin): Somehow unify this with MakeExtension() in
 // extension_util_unittest.cc.
 scoped_refptr<Extension> CreateExtension(
-    const FilePath& base_dir, const std::string& name,
-    Extension::Type type) {
+    const FilePath& base_dir, const std::string& name, Manifest::Type type) {
   DictionaryValue source;
   source.SetString(extension_manifest_keys::kName, name);
   const std::string& public_key = NameToPublicKey(name);
   source.SetString(extension_manifest_keys::kPublicKey, public_key);
   source.SetString(extension_manifest_keys::kVersion, "0.0.0.0");
   switch (type) {
-    case Extension::TYPE_EXTENSION:
+    case Manifest::TYPE_EXTENSION:
       // Do nothing.
       break;
-    case Extension::TYPE_THEME:
+    case Manifest::TYPE_THEME:
       source.Set(extension_manifest_keys::kTheme, new DictionaryValue());
       break;
-    case Extension::TYPE_HOSTED_APP:
-    case Extension::TYPE_LEGACY_PACKAGED_APP:
+    case Manifest::TYPE_HOSTED_APP:
+    case Manifest::TYPE_LEGACY_PACKAGED_APP:
       source.Set(extension_manifest_keys::kApp, new DictionaryValue());
       source.SetString(extension_manifest_keys::kLaunchWebURL,
                        "http://www.example.com");
       break;
-    case Extension::TYPE_PLATFORM_APP: {
+    case Manifest::TYPE_PLATFORM_APP: {
       source.Set(extension_manifest_keys::kApp, new DictionaryValue());
       source.Set(extension_manifest_keys::kPlatformAppBackground,
                  new DictionaryValue());
       ListValue* scripts = new ListValue();
       scripts->AppendString("main.js");
       source.Set(extension_manifest_keys::kPlatformAppBackgroundScripts,
                  scripts);
       break;
     }
     default:
       ADD_FAILURE();
       return NULL;
   }
   const FilePath sub_dir = FilePath().AppendASCII(name);
   FilePath extension_dir;
   if (!file_util::PathExists(base_dir) &&
       !file_util::CreateDirectory(base_dir)) {
     ADD_FAILURE();
     return NULL;
   }
   if (!file_util::CreateTemporaryDirInDir(
           base_dir, sub_dir.value(), &extension_dir)) {
     ADD_FAILURE();
     return NULL;
   }
   std::string error;
   scoped_refptr<Extension> extension =
-      Extension::Create(extension_dir, Extension::INTERNAL, source,
+      Extension::Create(extension_dir, Manifest::INTERNAL, source,
                         Extension::NO_FLAGS, &error);
   if (!error.empty()) {
     ADD_FAILURE() << error;
     return NULL;
   }
   if (!extension.get()) {
     ADD_FAILURE();
     return NULL;
   }
   if (extension->name() != name) {
     EXPECT_EQ(name, extension->name());
     return NULL;
   }
   if (extension->GetType() != type) {
     EXPECT_EQ(type, extension->GetType());
     return NULL;
   }
   return extension;
 }
 
 }  // namespace
 
 scoped_refptr<Extension> SyncExtensionHelper::GetExtension(
-    Profile* profile, const std::string& name,
-    Extension::Type type) {
+    Profile* profile, const std::string& name, Manifest::Type type) {
   if (name.empty()) {
     ADD_FAILURE();
     return NULL;
   }
   ProfileExtensionNameMap::iterator it = profile_extensions_.find(profile);
   if (it == profile_extensions_.end()) {
     ADD_FAILURE();
     return NULL;
   }
   ExtensionNameMap::const_iterator it2 = it->second.find(name);
@@ skipping 13 matching lines @@
     EXPECT_EQ(expected_id, extension->id());
     return NULL;
   }
   DVLOG(2) << "created extension with name = "
            << name << ", id = " << expected_id;
   (it->second)[name] = extension;
   id_to_name_[expected_id] = name;
   id_to_type_[expected_id] = type;
   return extension;
 }