ExtensionUpdater: Abstract ExtensionDownloader creation

chrome/browser/extensions/updater/extension_updater.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_updater.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/module/module.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/pending_extension_manager.h"
-#include "chrome/browser/extensions/updater/extension_downloader.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "crypto/sha2.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/pref_names.h"
@@ skipping 95 matching lines @@
   Time check_start;
 };
 
 ExtensionUpdater::ExtensionUpdater(
     ExtensionServiceInterface* service,
     ExtensionPrefs* extension_prefs,
     PrefService* prefs,
     Profile* profile,
     int frequency_seconds,
     ExtensionCache* cache,
-    scoped_ptr<IdentityProvider> webstore_identity_provider)
+    const ExtensionDownloader::Factory& downloader_factory)
     : alive_(false),
       weak_ptr_factory_(this),
       service_(service),
+      downloader_factory_(downloader_factory),
       frequency_seconds_(frequency_seconds),
       will_check_soon_(false),
       extension_prefs_(extension_prefs),
       prefs_(prefs),
       profile_(profile),
       next_request_id_(0),
       extension_registry_observer_(this),
       crx_install_is_running_(false),
-      extension_cache_(cache),
-      webstore_identity_provider_(webstore_identity_provider.release()) {
+      extension_cache_(cache) {
   DCHECK_GE(frequency_seconds_, 5);
   DCHECK_LE(frequency_seconds_, kMaxUpdateFrequencySeconds);
 #if defined(NDEBUG)
   // In Release mode we enforce that update checks don't happen too often.
   frequency_seconds_ = std::max(frequency_seconds_, kMinUpdateFrequencySeconds);
 #endif
   frequency_seconds_ = std::min(frequency_seconds_, kMaxUpdateFrequencySeconds);
 
   extension_registry_observer_.Add(ExtensionRegistry::Get(profile));
 }
 
 ExtensionUpdater::~ExtensionUpdater() {
   Stop();
 }
 
+void ExtensionUpdater::EnsureDownloaderCreated() {
+  if (!downloader_.get()) {
+    downloader_ = downloader_factory_.Run(this);
+  }
+}

[Yoyo Zhou, 2014/08/11 23:19:28]

nit: newline after

[Ken Rockot(use gerrit already), 2014/08/11 23:48:24]

Woops. Done.

 // The overall goal here is to balance keeping clients up to date while
 // avoiding a thundering herd against update servers.
 TimeDelta ExtensionUpdater::DetermineFirstCheckDelay() {
   DCHECK(alive_);
   // If someone's testing with a quick frequency, just allow it.
   if (frequency_seconds_ < kStartupWaitSeconds)
     return TimeDelta::FromSeconds(frequency_seconds_);
 
   // If we've never scheduled a check before, start at frequency_seconds_.
   if (!prefs_->HasPrefPath(pref_names::kNextUpdateCheck))
@@ skipping 157 matching lines @@
   VLOG(2) << "Starting update check " << request_id;
   if (params.ids.empty())
     NotifyStarted();
 
   DCHECK(alive_);
 
   InProgressCheck& request = requests_in_progress_[request_id];
   request.callback = params.callback;
   request.install_immediately = params.install_immediately;
 
-  if (!downloader_.get()) {
-    downloader_.reset(
-        new ExtensionDownloader(this,
-                                profile_->GetRequestContext(),
-                                webstore_identity_provider_.get()));
-  }
+  EnsureDownloaderCreated();
 
   // Add fetch records for extensions that should be fetched by an update URL.
   // These extensions are not yet installed. They come from group policy
   // and external install sources.
   const PendingExtensionManager* pending_extension_manager =
       service_->pending_extension_manager();
 
   std::list<std::string> pending_ids;
 
   if (params.ids.empty()) {
@@ skipping 281 matching lines @@
   const InProgressCheck& request = requests_in_progress_[request_id];
   if (request.in_progress_ids_.empty()) {
     VLOG(2) << "Finished update check " << request_id;
     if (!request.callback.is_null())
       request.callback.Run();
     requests_in_progress_.erase(request_id);
   }
 }
 
 }  // namespace extensions