Move PendingExtensionManager and PendingExtensionInfo into extensions namespace

chrome/browser/extensions/extension_service_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/browser/extensions/extension_service_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 2485 matching lines @@
   InitializeEmptyExtensionService();
 
   const std::string kFakeId(all_zero);
   const GURL kFakeUpdateURL("http:://fake.update/url");
   const bool kFakeInstallSilently(true);
 
   EXPECT_TRUE(service_->pending_extension_manager()->AddFromSync(
       kFakeId, kFakeUpdateURL, &IsExtension,
       kFakeInstallSilently));
 
-  const PendingExtensionInfo* pending_extension_info;
+  const extensions::PendingExtensionInfo* pending_extension_info;
   ASSERT_TRUE((pending_extension_info = service_->pending_extension_manager()->
       GetById(kFakeId)));
   EXPECT_EQ(kFakeUpdateURL, pending_extension_info->update_url());
   EXPECT_EQ(&IsExtension, pending_extension_info->should_allow_install_);
   EXPECT_EQ(kFakeInstallSilently, pending_extension_info->install_silently());
 }
 
 namespace {
 const char kGoodId[] = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
 const char kGoodUpdateURL[] = "http://good.update/url";
@@ skipping 82 matching lines @@
 // but a sync update should not overwrite a non-sync update.
 TEST_F(ExtensionServiceTest, UpdatePendingExternalCrxWinsOverSync) {
   InitializeEmptyExtensionService();
 
   // Add a crx to be installed from the update mechanism.
   EXPECT_TRUE(service_->pending_extension_manager()->AddFromSync(
       kGoodId, GURL(kGoodUpdateURL), &IsExtension,
       kGoodInstallSilently));
 
   // Check that there is a pending crx, with is_from_sync set to true.
-  const PendingExtensionInfo* pending_extension_info;
+  const extensions::PendingExtensionInfo* pending_extension_info;
   ASSERT_TRUE((pending_extension_info = service_->pending_extension_manager()->
       GetById(kGoodId)));
   EXPECT_TRUE(pending_extension_info->is_from_sync());
 
   // Add a crx to be updated, with the same ID, from a non-sync source.
   EXPECT_TRUE(service_->pending_extension_manager()->AddFromExternalUpdateUrl(
       kGoodId, GURL(kGoodUpdateURL), Extension::EXTERNAL_PREF_DOWNLOAD));
 
   // Check that there is a pending crx, with is_from_sync set to false.
   ASSERT_TRUE((pending_extension_info = service_->pending_extension_manager()->
@@ skipping 2144 matching lines @@
   list[0] = sync_change;
 
 
   EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
   EXPECT_FALSE(service_->IsIncognitoEnabled(good_crx));
   service_->ProcessSyncChanges(FROM_HERE, list);
   EXPECT_TRUE(service_->updater()->WillCheckSoon());
   EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
   EXPECT_TRUE(service_->IsIncognitoEnabled(good_crx));
 
-  const PendingExtensionInfo* info;
+  const extensions::PendingExtensionInfo* info;
   EXPECT_TRUE((info = service_->pending_extension_manager()->
       GetById(good_crx)));
   EXPECT_EQ(ext_specifics->update_url(), info->update_url().spec());
   EXPECT_TRUE(info->is_from_sync());
   EXPECT_TRUE(info->install_silently());
   EXPECT_EQ(Extension::INTERNAL, info->install_source());
   // TODO(akalin): Figure out a way to test |info.ShouldAllowInstall()|.
 }
 
 TEST_F(ExtensionServiceTest, InstallPriorityExternalUpdateUrl) {
   InitializeEmptyExtensionService();
 
   FilePath path = data_dir_.AppendASCII("good.crx");
   InstallCRX(path, INSTALL_NEW);
   ValidatePrefKeyCount(1u);
   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
   ValidateIntegerPref(good_crx, "location", Extension::INTERNAL);
 
-  PendingExtensionManager* pending = service_->pending_extension_manager();
+  extensions::PendingExtensionManager* pending =
+      service_->pending_extension_manager();
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 
   // Skip install when the location is the same.
   EXPECT_FALSE(
       service_->OnExternalExtensionUpdateUrlFound(
           kGoodId, GURL(kGoodUpdateURL), Extension::INTERNAL));
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 
   // Install when the location has higher priority.
   EXPECT_TRUE(
@@ skipping 40 matching lines @@
   ASSERT_EQ(Extension::EXTERNAL_REGISTRY,
             Extension::GetHigherPriorityLocation(Extension::EXTERNAL_REGISTRY,
                                                  Extension::EXTERNAL_PREF));
   ASSERT_EQ(Extension::EXTERNAL_REGISTRY,
             Extension::GetHigherPriorityLocation(Extension::EXTERNAL_REGISTRY,
                                                  Extension::INTERNAL));
   ASSERT_EQ(Extension::EXTERNAL_PREF,
             Extension::GetHigherPriorityLocation(Extension::EXTERNAL_PREF,
                                                  Extension::INTERNAL));
 
-  PendingExtensionManager* pending = service_->pending_extension_manager();
+  extensions::PendingExtensionManager* pending =
+      service_->pending_extension_manager();
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 
   // Simulate an external source adding the extension as INTERNAL.
   EXPECT_TRUE(
       service_->OnExternalExtensionFileFound(
           kGoodId, &older_version, kInvalidPathToCrx,
           Extension::INTERNAL, kCreationFlags, kDontMarkAcknowledged));
   EXPECT_TRUE(pending->IsIdPending(kGoodId));
   WaitForCrxInstall(kInvalidPathToCrx, INSTALL_FAILED);
 
@@ skipping 117 matching lines @@
 TEST_F(ExtensionServiceTest, ConcurrentExternalLocalFile) {
   Version kVersion123("1.2.3");
   Version kVersion124("1.2.4");
   Version kVersion125("1.2.5");
   const FilePath kInvalidPathToCrx = FilePath();
   const int kCreationFlags = 0;
   const bool kDontMarkAcknowledged = false;
 
   InitializeEmptyExtensionService();
 
-  PendingExtensionManager* pending = service_->pending_extension_manager();
+  extensions::PendingExtensionManager* pending =
+      service_->pending_extension_manager();
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 
   // An external provider starts installing from a local crx.
   EXPECT_TRUE(
       service_->OnExternalExtensionFileFound(
           kGoodId, &kVersion123, kInvalidPathToCrx,
           Extension::EXTERNAL_PREF, kCreationFlags, kDontMarkAcknowledged));
-  const PendingExtensionInfo* info;
+  const extensions::PendingExtensionInfo* info;
   EXPECT_TRUE((info = pending->GetById(kGoodId)));
   EXPECT_TRUE(info->version().IsValid());
   EXPECT_TRUE(info->version().Equals(kVersion123));
 
   // Adding a newer version overrides the currently pending version.
   EXPECT_TRUE(
       service_->OnExternalExtensionFileFound(
           kGoodId, &kVersion124, kInvalidPathToCrx,
           Extension::EXTERNAL_PREF, kCreationFlags, kDontMarkAcknowledged));
   EXPECT_TRUE((info = pending->GetById(kGoodId)));
@@ skipping 87 matching lines @@
 
   // Fake a policy install.
   bool AddPendingPolicyInstall() {
     // Get path to the CRX with id |kGoodId|.
     return service_->OnExternalExtensionUpdateUrlFound(
         crx_id_, GURL(), Extension::EXTERNAL_POLICY_DOWNLOAD);
   }
 
   // Get the install source of a pending extension.
   Extension::Location GetPendingLocation() {
-    const PendingExtensionInfo* info;
+    const extensions::PendingExtensionInfo* info;
     EXPECT_TRUE((info = service_->pending_extension_manager()->
         GetById(crx_id_)));
     return info->install_source();
   }
 
   // Is an extension pending from a sync request?
   bool GetPendingIsFromSync() {
-    const PendingExtensionInfo* info;
+    const extensions::PendingExtensionInfo* info;
     EXPECT_TRUE((info = service_->pending_extension_manager()->
         GetById(crx_id_)));
     return info->is_from_sync();
   }
 
   // Is the CRX id these tests use pending?
   bool IsCrxPending() {
     return service_->pending_extension_manager()->IsIdPending(crx_id_);
   }
 
@@ skipping 111 matching lines @@
   // This should NOT trigger an alert.
   provider->UpdateOrAddExtension(hosted_app, "1.0.0.0",
                                  data_dir_.AppendASCII("hosted_app.crx"));
 
   service_->CheckForExternalUpdates();
   loop_.RunAllPending();
 
   ASSERT_TRUE(service_->PopulateExtensionErrorUI(extension_error_ui.get()));
   ASSERT_EQ(1u, extension_error_ui->get_external_extension_ids()->size());
 }