Revert of base: Remove using:: declaration from version.h header.

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 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 <algorithm>
 #include <set>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
@@ skipping 258 matching lines @@
 
   void RemoveExtension(const std::string& id) {
     extension_map_.erase(id);
   }
 
   // ExternalProvider implementation:
   void VisitRegisteredExtension() override {
     visit_count_++;
     for (DataMap::const_iterator i = extension_map_.begin();
          i != extension_map_.end(); ++i) {
-      base::Version version(i->second.first);
+      Version version(i->second.first);
 
       visitor_->OnExternalExtensionFileFound(
           i->first, &version, i->second.second, location_,
           Extension::NO_FLAGS, false, false);
     }
     visitor_->OnExternalProviderReady(this);
   }
 
   bool HasExtension(const std::string& id) const override {
     return extension_map_.find(id) != extension_map_.end();
   }
 
   bool GetExtensionDetails(const std::string& id,
                            Manifest::Location* location,
-                           scoped_ptr<base::Version>* version) const override {
+                           scoped_ptr<Version>* version) const override {
     DataMap::const_iterator it = extension_map_.find(id);
     if (it == extension_map_.end())
       return false;
 
     if (version)
-      version->reset(new base::Version(it->second.first));
+      version->reset(new Version(it->second.first));
 
     if (location)
       *location = location_;
 
     return true;
   }
 
   bool IsReady() const override { return true; }
 
   void ServiceShutdown() override {}
@@ skipping 66 matching lines @@
 
     // Reset our counter.
     ids_found_ = 0;
     // Ask the provider to look up all extensions and return them.
     provider_->VisitRegisteredExtension();
 
     return ids_found_;
   }
 
   bool OnExternalExtensionFileFound(const std::string& id,
-                                    const base::Version* version,
+                                    const Version* version,
                                     const base::FilePath& path,
                                     Manifest::Location unused,
                                     int creation_flags,
                                     bool mark_acknowledged,
                                     bool install_immediately) override {
     EXPECT_EQ(expected_creation_flags_, creation_flags);
 
     ++ids_found_;
     base::DictionaryValue* pref;
     // This tests is to make sure that the provider only notifies us of the
     // values we gave it. So if the id we doesn't exist in our internal
     // dictionary then something is wrong.
     EXPECT_TRUE(prefs_->GetDictionary(id, &pref))
        << "Got back ID (" << id.c_str() << ") we weren't expecting";
 
     EXPECT_TRUE(path.IsAbsolute());
     if (!fake_base_path_.empty())
       EXPECT_TRUE(fake_base_path_.IsParent(path));
 
     if (pref) {
       EXPECT_TRUE(provider_->HasExtension(id));
 
       // Ask provider if the extension we got back is registered.
       Manifest::Location location = Manifest::INVALID_LOCATION;
-      scoped_ptr<base::Version> v1;
+      scoped_ptr<Version> v1;
       base::FilePath crx_path;
 
       EXPECT_TRUE(provider_->GetExtensionDetails(id, NULL, &v1));
       EXPECT_STREQ(version->GetString().c_str(), v1->GetString().c_str());
 
-      scoped_ptr<base::Version> v2;
+      scoped_ptr<Version> v2;
       EXPECT_TRUE(provider_->GetExtensionDetails(id, &location, &v2));
       EXPECT_STREQ(version->GetString().c_str(), v1->GetString().c_str());
       EXPECT_STREQ(version->GetString().c_str(), v2->GetString().c_str());
       EXPECT_EQ(Manifest::EXTERNAL_PREF, location);
 
       // Remove it so we won't count it ever again.
       prefs_->Remove(id, NULL);
     }
     return true;
   }
@@ skipping 10 matching lines @@
     // values we gave it. So if the id we doesn't exist in our internal
     // dictionary then something is wrong.
     EXPECT_TRUE(prefs_->GetDictionary(id, &pref))
        << L"Got back ID (" << id.c_str() << ") we weren't expecting";
     EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, location);
 
     if (pref) {
       EXPECT_TRUE(provider_->HasExtension(id));
 
       // External extensions with update URLs do not have versions.
-      scoped_ptr<base::Version> v1;
+      scoped_ptr<Version> v1;
       Manifest::Location location1 = Manifest::INVALID_LOCATION;
       EXPECT_TRUE(provider_->GetExtensionDetails(id, &location1, &v1));
       EXPECT_FALSE(v1.get());
       EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, location1);
 
       std::string parsed_install_parameter;
       pref->GetString("install_parameter", &parsed_install_parameter);
       EXPECT_EQ(parsed_install_parameter, install_parameter);
 
       // Remove it so we won't count it again.
@@ skipping 1106 matching lines @@
 // extension object.
 TEST_F(ExtensionServiceTest, InstallingExternalExtensionWithFlags) {
   const char kPrefFromBookmark[] = "from_bookmark";
 
   InitializeEmptyExtensionService();
 
   base::FilePath path = data_dir().AppendASCII("good.crx");
   service()->set_extensions_enabled(true);
 
   // Register and install an external extension.
-  base::Version version("1.0.0.0");
+  Version version("1.0.0.0");
   content::WindowedNotificationObserver observer(
       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
   if (service()->OnExternalExtensionFileFound(
           good_crx,
           &version,
           path,
           Manifest::EXTERNAL_PREF,
           Extension::FROM_BOOKMARK,
           false /* mark_acknowledged */,
@@ skipping 16 matching lines @@
 }
 
 // Test the handling of Extension::EXTERNAL_EXTENSION_UNINSTALLED
 TEST_F(ExtensionServiceTest, UninstallingExternalExtensions) {
   InitializeEmptyExtensionService();
 
   base::FilePath path = data_dir().AppendASCII("good.crx");
   service()->set_extensions_enabled(true);
 
   // Install an external extension.
-  base::Version version("1.0.0.0");
+  Version version("1.0.0.0");
   content::WindowedNotificationObserver observer(
       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
   if (service()->OnExternalExtensionFileFound(good_crx,
                                               &version,
                                               path,
                                               Manifest::EXTERNAL_PREF,
                                               Extension::NO_FLAGS,
                                               false,
                                               false)) {
@@ skipping 13 matching lines @@
                                           path,
                                           Manifest::EXTERNAL_PREF,
                                           Extension::NO_FLAGS,
                                           false,
                                           false);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(NULL == service()->GetExtensionById(good_crx, false));
   ValidateIntegerPref(good_crx, "state",
                       Extension::EXTERNAL_EXTENSION_UNINSTALLED);
 
-  version = base::Version("1.0.0.1");
+  version = Version("1.0.0.1");
   // Repeat the same thing with a newer version of the extension.
   path = data_dir().AppendASCII("good2.crx");
   service()->OnExternalExtensionFileFound(good_crx,
                                           &version,
                                           path,
                                           Manifest::EXTERNAL_PREF,
                                           Extension::NO_FLAGS,
                                           false,
                                           false);
   base::RunLoop().RunUntilIdle();
@@ skipping 39 matching lines @@
   MockExtensionProvider provider(NULL, Manifest::EXTERNAL_REGISTRY);
   service()->OnExternalProviderReady(&provider);
 }
 
 // Test that external extensions with incorrect IDs are not installed.
 TEST_F(ExtensionServiceTest, FailOnWrongId) {
   InitializeEmptyExtensionService();
   base::FilePath path = data_dir().AppendASCII("good.crx");
   service()->set_extensions_enabled(true);
 
-  base::Version version("1.0.0.0");
+  Version version("1.0.0.0");
 
   const std::string wrong_id = all_zero;
   const std::string correct_id = good_crx;
   ASSERT_NE(correct_id, wrong_id);
 
   // Install an external extension with an ID from the external
   // source that is not equal to the ID in the extension manifest.
   content::WindowedNotificationObserver observer(
       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
@@ skipping 25 matching lines @@
 }
 
 // Test that external extensions with incorrect versions are not installed.
 TEST_F(ExtensionServiceTest, FailOnWrongVersion) {
   InitializeEmptyExtensionService();
   base::FilePath path = data_dir().AppendASCII("good.crx");
   service()->set_extensions_enabled(true);
 
   // Install an external extension with a version from the external
   // source that is not equal to the version in the extension manifest.
-  base::Version wrong_version("1.2.3.4");
+  Version wrong_version("1.2.3.4");
   content::WindowedNotificationObserver observer(
       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
   service()->OnExternalExtensionFileFound(good_crx,
                                           &wrong_version,
                                           path,
                                           Manifest::EXTERNAL_PREF,
                                           Extension::NO_FLAGS,
                                           false,
                                           false);
 
   observer.Wait();
   ASSERT_FALSE(service()->GetExtensionById(good_crx, false));
 
   // Try again with the right version. Expect success.
   service()->pending_extension_manager()->Remove(good_crx);
-  base::Version correct_version("1.0.0.0");
+  Version correct_version("1.0.0.0");
   content::WindowedNotificationObserver observer2(
       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
   if (service()->OnExternalExtensionFileFound(good_crx,
                                               &correct_version,
                                               path,
                                               Manifest::EXTERNAL_PREF,
                                               Extension::NO_FLAGS,
                                               false,
                                               false)) {
@@ skipping 1402 matching lines @@
   const Extension* good = InstallCRX(path, INSTALL_NEW);
   ASSERT_EQ(1u, registry()->enabled_extensions().size());
 
   EXPECT_FALSE(good->is_theme());
 
   // Use AddExtensionImpl() as AddFrom*() would balk.
   service()->pending_extension_manager()->AddExtensionImpl(
       good->id(),
       std::string(),
       extensions::ManifestURL::GetUpdateURL(good),
-      base::Version(),
+      Version(),
       &IsExtension,
       kGoodIsFromSync,
       Manifest::INTERNAL,
       Extension::NO_FLAGS,
       false,
       kGoodRemoteInstall);
   UpdateExtension(good->id(), path, ENABLED);
 
   EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(kGoodId));
 }
@@ skipping 4043 matching lines @@
                                                    std::string(),
                                                    GURL(kGoodUpdateURL),
                                                    Manifest::INTERNAL,
                                                    Extension::NO_FLAGS,
                                                    false));
 
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 }
 
 TEST_F(ExtensionServiceTest, InstallPriorityExternalLocalFile) {
-  base::Version older_version("0.1.0.0");
-  base::Version newer_version("2.0.0.0");
+  Version older_version("0.1.0.0");
+  Version newer_version("2.0.0.0");
 
   // We don't want the extension to be installed.  A path that doesn't
   // point to a valid CRX ensures this.
   const base::FilePath kInvalidPathToCrx(FILE_PATH_LITERAL("invalid_path"));
 
   const int kCreationFlags = 0;
   const bool kDontMarkAcknowledged = false;
   const bool kDontInstallImmediately = false;
 
   InitializeEmptyExtensionService();
@@ skipping 211 matching lines @@
       &newer_version,
       kInvalidPathToCrx,
       Manifest::EXTERNAL_PREF,
       kCreationFlags,
       kDontMarkAcknowledged,
       kDontInstallImmediately));
   EXPECT_TRUE(pending->IsIdPending(kGoodId));
 }
 
 TEST_F(ExtensionServiceTest, ConcurrentExternalLocalFile) {
-  base::Version kVersion123("1.2.3");
-  base::Version kVersion124("1.2.4");
-  base::Version kVersion125("1.2.5");
+  Version kVersion123("1.2.3");
+  Version kVersion124("1.2.4");
+  Version kVersion125("1.2.5");
   const base::FilePath kInvalidPathToCrx(FILE_PATH_LITERAL("invalid_path"));
   const int kCreationFlags = 0;
   const bool kDontMarkAcknowledged = false;
   const bool kDontInstallImmediately = false;
 
   InitializeEmptyExtensionService();
 
   extensions::PendingExtensionManager* pending =
       service()->pending_extension_manager();
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
@@ skipping 106 matching lines @@
         crx_id_,
         std::string(),
         GURL(),
         Manifest::EXTERNAL_PREF_DOWNLOAD,
         Extension::NO_FLAGS,
         false);
   }
 
   // Fake an external file from external_extensions.json.
   bool AddPendingExternalPrefFileInstall() {
-    base::Version version("1.0.0.0");
+    Version version("1.0.0.0");
 
     return service()->OnExternalExtensionFileFound(crx_id_,
                                                    &version,
                                                    crx_path_,
                                                    Manifest::EXTERNAL_PREF,
                                                    Extension::NO_FLAGS,
                                                    false,
                                                    false);
   }
 
@@ skipping 478 matching lines @@
 
   service()->Observe(chrome::NOTIFICATION_PROFILE_DESTRUCTION_STARTED,
                      content::Source<Profile>(profile()),
                      content::NotificationService::NoDetails());
   EXPECT_EQ(UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN, unloaded_reason_);
   EXPECT_EQ(0u, registry()->enabled_extensions().size());
   EXPECT_EQ(0u, registry()->disabled_extensions().size());
   EXPECT_EQ(0u, registry()->terminated_extensions().size());
   EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
 }