ExtensionUpdater: Abstract ExtensionDownloader creation

chrome/browser/extensions/updater/extension_downloader.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/updater/extension_downloader.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 158 matching lines @@
       version(version),
       request_ids(request_ids),
       credentials(CREDENTIALS_NONE),
       oauth2_attempt_count(0) {
 }
 
 ExtensionDownloader::ExtensionFetch::~ExtensionFetch() {}
 
 ExtensionDownloader::ExtensionDownloader(
     ExtensionDownloaderDelegate* delegate,
-    net::URLRequestContextGetter* request_context,
-    IdentityProvider* webstore_identity_provider)
+    net::URLRequestContextGetter* request_context)
     : OAuth2TokenService::Consumer(kTokenServiceConsumerId),
       delegate_(delegate),
       request_context_(request_context),
       weak_ptr_factory_(this),
       manifests_queue_(&kDefaultBackoffPolicy,
                        base::Bind(&ExtensionDownloader::CreateManifestFetcher,
                                   base::Unretained(this))),
       extensions_queue_(&kDefaultBackoffPolicy,
                         base::Bind(&ExtensionDownloader::CreateExtensionFetcher,
                                    base::Unretained(this))),
-      extension_cache_(NULL),
-      identity_provider_(webstore_identity_provider) {
+      extension_cache_(NULL) {
   DCHECK(delegate_);
   DCHECK(request_context_);
 }
 
 ExtensionDownloader::~ExtensionDownloader() {}
 
 bool ExtensionDownloader::AddExtension(const Extension& extension,
                                        int request_id) {
   // Skip extensions with empty update URLs converted from user
   // scripts.
@@ skipping 69 matching lines @@
                             request_id));
   DCHECK(blacklist_fetch->base_url().SchemeIsSecure());
   blacklist_fetch->AddExtension(kBlacklistAppID,
                                 version,
                                 &ping_data,
                                 std::string(),
                                 kDefaultInstallSource);
   StartUpdateCheck(blacklist_fetch.Pass());
 }
 
+void ExtensionDownloader::SetWebstoreIdentityProvider(
+    scoped_ptr<IdentityProvider> identity_provider) {
+  identity_provider_.swap(identity_provider);
+}
+
 bool ExtensionDownloader::AddExtensionData(const std::string& id,
                                            const Version& version,
                                            Manifest::Type extension_type,
                                            const GURL& extension_update_url,
                                            const std::string& update_url_data,
                                            int request_id) {
   GURL update_url(extension_update_url);
   // Skip extensions with non-empty invalid update URLs.
   if (!update_url.is_empty() && !update_url.is_valid()) {
     LOG(WARNING) << "Extension " << id << " has invalid update url "
@@ skipping 447 matching lines @@
     extension_fetcher_->SaveResponseToTemporaryFile(
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
   }
 
   if (fetch->credentials == ExtensionFetch::CREDENTIALS_OAUTH2_TOKEN &&
       is_secure) {
     if (access_token_.empty()) {
       // We should try OAuth2, but we have no token cached. This
       // ExtensionFetcher will be started once the token fetch is complete,
       // in either OnTokenFetchSuccess or OnTokenFetchFailure.
-      DCHECK(identity_provider_);
+      DCHECK(identity_provider_.get());
       OAuth2TokenService::ScopeSet webstore_scopes;
       webstore_scopes.insert(kWebstoreOAuth2Scope);
       access_token_request_ =
           identity_provider_->GetTokenService()->StartRequest(
               identity_provider_->GetActiveAccountId(),
               webstore_scopes,
               this);
       return;
     }
     extension_fetcher_->AddExtraRequestHeader(
@@ skipping 104 matching lines @@
       } else {
         fetch->credentials = ExtensionFetch::CREDENTIALS_COOKIES;
       }
       return true;
     case ExtensionFetch::CREDENTIALS_OAUTH2_TOKEN:
       fetch->oauth2_attempt_count++;
       // OAuth2 may fail due to an expired access token, in which case we
       // should invalidate the token and try again.
       if (response_code == net::HTTP_UNAUTHORIZED &&
           fetch->oauth2_attempt_count <= kMaxOAuth2Attempts) {
-        DCHECK(identity_provider_ != NULL);
+        DCHECK(identity_provider_.get());
         OAuth2TokenService::ScopeSet webstore_scopes;
         webstore_scopes.insert(kWebstoreOAuth2Scope);
         identity_provider_->GetTokenService()->InvalidateToken(
             identity_provider_->GetActiveAccountId(),
             webstore_scopes,
             access_token_);
         access_token_.clear();
         return true;
       }
       // Either there is no Gaia identity available, the active identity
@@ skipping 34 matching lines @@
 
 void ExtensionDownloader::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
   // If we fail to get an access token, kick the pending fetch and let it fall
   // back on cookies.
   extension_fetcher_->Start();
 }
 
 }  // namespace extensions