Consistently use namespaced base::Version in extensions code.

chrome/browser/extensions/pending_extension_info.h

 // Copyright 2014 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_PENDING_EXTENSION_INFO_H_
 #define CHROME_BROWSER_EXTENSIONS_PENDING_EXTENSION_INFO_H_
 
 #include <string>
 
 #include "base/gtest_prod_util.h"
@@ skipping 12 matching lines @@
 // default one is assumed.
 // TODO(skerner): Make this class an implementation detail of
 // PendingExtensionManager, and remove all other users.
 class PendingExtensionInfo {
  public:
   typedef bool (*ShouldAllowInstallPredicate)(const Extension*);
 
   PendingExtensionInfo(const std::string& id,
                        const std::string& install_parameter,
                        const GURL& update_url,
-                       const Version& version,
+                       const base::Version& version,
                        ShouldAllowInstallPredicate should_allow_install,
                        bool is_from_sync,
                        Manifest::Location install_source,
                        int creation_flags,
                        bool mark_acknowledged,
                        bool remote_install);
 
   // Required for STL container membership.  Should not be used directly.
   PendingExtensionInfo();
 
   PendingExtensionInfo(const PendingExtensionInfo& other);
 
   ~PendingExtensionInfo();
 
   // Consider two PendingExtensionInfos equal if their ids are equal.
   bool operator==(const PendingExtensionInfo& rhs) const;
 
   const std::string& id() const { return id_; }
   const GURL& update_url() const { return update_url_; }
-  const Version& version() const { return version_; }
+  const base::Version& version() const { return version_; }
   const std::string& install_parameter() const { return install_parameter_; }
 
   // ShouldAllowInstall() returns the result of running constructor argument
   // |should_allow_install| on an extension. After an extension is unpacked,
   // this function is run. If it returns true, the extension is installed.
   // If not, the extension is discarded. This allows creators of
   // PendingExtensionInfo objects to ensure that extensions meet some criteria
   // that can only be tested once the extension is unpacked.
   bool ShouldAllowInstall(const Extension* extension) const {
     return should_allow_install_(extension);
   }
   bool is_from_sync() const { return is_from_sync_; }
   Manifest::Location install_source() const { return install_source_; }
   int creation_flags() const { return creation_flags_; }
   bool mark_acknowledged() const { return mark_acknowledged_; }
   bool remote_install() const { return remote_install_; }
 
   // Returns -1, 0 or 1 if |this| has lower, equal or higher precedence than
   // |other|, respectively. "Equal" precedence means that the version and the
   // install source match. "Higher" precedence means that the version is newer,
   // or the version matches but the install source has higher priority.
   // It is only valid to invoke this when the ids match.
   int CompareTo(const PendingExtensionInfo& other) const;
 
  private:
   std::string id_;
 
   GURL update_url_;
-  Version version_;
+  base::Version version_;
   std::string install_parameter_;
 
   // When the extension is about to be installed, this function is
   // called.  If this function returns true, the install proceeds.  If
   // this function returns false, the install is aborted.
   ShouldAllowInstallPredicate should_allow_install_;
 
   bool is_from_sync_;  // This update check was initiated from sync.
   Manifest::Location install_source_;
   int creation_flags_;
   bool mark_acknowledged_;
   bool remote_install_;
 
   FRIEND_TEST_ALL_PREFIXES(::ExtensionServiceTest, AddPendingExtensionFromSync);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_PENDING_EXTENSION_INFO_H_