Move ExtensionDownloader to //extensions

extensions/browser/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 "extensions/browser/updater/extension_downloader.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
@@ skipping 28 matching lines @@
 using base::TimeDelta;
 using content::BrowserThread;
 
 namespace extensions {
 
 const char ExtensionDownloader::kBlacklistAppID[] = "com.google.crx.blacklist";
 
 namespace {
 
 const net::BackoffEntry::Policy kDefaultBackoffPolicy = {
-  // Number of initial errors (in sequence) to ignore before applying
-  // exponential back-off rules.
-  0,
+    // Number of initial errors (in sequence) to ignore before applying
+    // exponential back-off rules.
+    0,
 
-  // Initial delay for exponential back-off in ms.
-  2000,
+    // Initial delay for exponential back-off in ms.
+    2000,
 
-  // Factor by which the waiting time will be multiplied.
-  2,
+    // Factor by which the waiting time will be multiplied.
+    2,
 
-  // Fuzzing percentage. ex: 10% will spread requests randomly
-  // between 90%-100% of the calculated time.
-  0.1,
+    // Fuzzing percentage. ex: 10% will spread requests randomly
+    // between 90%-100% of the calculated time.
+    0.1,
 
-  // Maximum amount of time we are willing to delay our request in ms.
-  -1,
+    // Maximum amount of time we are willing to delay our request in ms.
+    -1,
 
-  // Time to keep an entry from being discarded even when it
-  // has no significant state, -1 to never discard.
-  -1,
+    // Time to keep an entry from being discarded even when it
+    // has no significant state, -1 to never discard.
+    -1,
 
-  // Don't use initial delay unless the last request was an error.
-  false,
+    // Don't use initial delay unless the last request was an error.
+    false,
 };
 
 const char kAuthUserQueryKey[] = "authuser";
 
 const int kMaxAuthUserValue = 10;
 const int kMaxOAuth2Attempts = 3;
 
 const char kNotFromWebstoreInstallSource[] = "notfromwebstore";
 const char kDefaultInstallSource[] = "";
 
@@ skipping 54 matching lines @@
   url::Component new_query(0, new_query_string.size());
   url::Replacements<char> replacements;
   replacements.SetQuery(new_query_string.c_str(), new_query);
   *url = url->ReplaceComponents(replacements);
   return true;
 }
 
 }  // namespace
 
 UpdateDetails::UpdateDetails(const std::string& id, const Version& version)
-    : id(id), version(version) {}
+    : id(id), version(version) {
+}
 
-UpdateDetails::~UpdateDetails() {}
+UpdateDetails::~UpdateDetails() {
+}
 
 ExtensionDownloader::ExtensionFetch::ExtensionFetch()
     : url(), credentials(CREDENTIALS_NONE) {
 }
 
 ExtensionDownloader::ExtensionFetch::ExtensionFetch(
     const std::string& id,
     const GURL& url,
     const std::string& package_hash,
     const std::string& version,
     const std::set<int>& request_ids)
     : id(id),
       url(url),
       package_hash(package_hash),
       version(version),
       request_ids(request_ids),
       credentials(CREDENTIALS_NONE),
       oauth2_attempt_count(0) {
 }
 
-ExtensionDownloader::ExtensionFetch::~ExtensionFetch() {}
+ExtensionDownloader::ExtensionFetch::~ExtensionFetch() {
+}
 
 ExtensionDownloader::ExtensionDownloader(
     ExtensionDownloaderDelegate* delegate,
     net::URLRequestContextGetter* request_context)
     : OAuth2TokenService::Consumer(kTokenServiceConsumerId),
       delegate_(delegate),
       request_context_(request_context),
       manifests_queue_(&kDefaultBackoffPolicy,
                        base::Bind(&ExtensionDownloader::CreateManifestFetcher,
                                   base::Unretained(this))),
       extensions_queue_(&kDefaultBackoffPolicy,
                         base::Bind(&ExtensionDownloader::CreateExtensionFetcher,
                                    base::Unretained(this))),
       extension_cache_(NULL),
       enable_extra_update_metrics_(false),
       weak_ptr_factory_(this) {
   DCHECK(delegate_);
   DCHECK(request_context_.get());
 }
 
-ExtensionDownloader::~ExtensionDownloader() {}
+ExtensionDownloader::~ExtensionDownloader() {
+}
 
 bool ExtensionDownloader::AddExtension(const Extension& extension,
                                        int request_id) {
   // Skip extensions with empty update URLs converted from user
   // scripts.
   if (extension.converted_from_user_script() &&
       ManifestURL::GetUpdateURL(&extension).is_empty()) {
     return false;
   }
 
   // If the extension updates itself from the gallery, ignore any update URL
   // data.  At the moment there is no extra data that an extension can
   // communicate to the the gallery update servers.
   std::string update_url_data;
   if (!ManifestURL::UpdatesFromGallery(&extension))
     update_url_data = delegate_->GetUpdateUrlData(extension.id());
 
   std::string install_source;
-  bool force_update = delegate_->ShouldForceUpdate(extension.id(),
-                                                   &install_source);
+  bool force_update =
+      delegate_->ShouldForceUpdate(extension.id(), &install_source);
   return AddExtensionData(extension.id(),
                           *extension.version(),
                           extension.GetType(),
                           ManifestURL::GetUpdateURL(&extension),
                           update_url_data,
                           request_id,
                           force_update,
                           install_source);
 }
 
@@ skipping 12 matching lines @@
                           update_url,
                           std::string(),
                           request_id,
                           false,
                           std::string());
 }
 
 void ExtensionDownloader::StartAllPending(ExtensionCache* cache) {
   if (cache) {
     extension_cache_ = cache;
-    extension_cache_->Start(base::Bind(
-        &ExtensionDownloader::DoStartAllPending,
-        weak_ptr_factory_.GetWeakPtr()));
+    extension_cache_->Start(base::Bind(&ExtensionDownloader::DoStartAllPending,
+                                       weak_ptr_factory_.GetWeakPtr()));
   } else {
     DoStartAllPending();
   }
 }
 
 void ExtensionDownloader::DoStartAllPending() {
   ReportStats();
   url_stats_ = URLStats();
 
   for (FetchMap::iterator it = fetches_preparing_.begin();
-       it != fetches_preparing_.end(); ++it) {
-    std::vector<linked_ptr<ManifestFetchData> >& list = it->second;
+       it != fetches_preparing_.end();
+       ++it) {
+    std::vector<linked_ptr<ManifestFetchData>>& list = it->second;
     for (size_t i = 0; i < list.size(); ++i) {
       StartUpdateCheck(scoped_ptr<ManifestFetchData>(list[i].release()));
     }
   }
   fetches_preparing_.clear();
 }
 
 void ExtensionDownloader::StartBlacklistUpdate(
     const std::string& version,
     const ManifestFetchData::PingData& ping_data,
@@ skipping 83 matching lines @@
   // webstore update URL.
   if (!extension_urls::IsWebstoreUpdateUrl(update_url) &&
       enable_extra_update_metrics_) {
     update_urls.push_back(extension_urls::GetWebstoreUpdateUrl());
   }
 
   for (size_t i = 0; i < update_urls.size(); ++i) {
     DCHECK(!update_urls[i].is_empty());
     DCHECK(update_urls[i].is_valid());
 
-    std::string install_source = i == 0 ?
-        kDefaultInstallSource : kNotFromWebstoreInstallSource;
+    std::string install_source =
+        i == 0 ? kDefaultInstallSource : kNotFromWebstoreInstallSource;
     if (!install_source_override.empty()) {
       install_source = install_source_override;
     }
 
     ManifestFetchData::PingData ping_data;
     ManifestFetchData::PingData* optional_ping_data = NULL;
     if (delegate_->GetPingDataForExtension(id, &ping_data))
       optional_ping_data = &ping_data;
 
     // Find or create a ManifestFetchData to add this extension to.
     bool added = false;
-    FetchMap::iterator existing_iter = fetches_preparing_.find(
-        std::make_pair(request_id, update_urls[i]));
+    FetchMap::iterator existing_iter =
+        fetches_preparing_.find(std::make_pair(request_id, update_urls[i]));
     if (existing_iter != fetches_preparing_.end() &&
         !existing_iter->second.empty()) {
       // Try to add to the ManifestFetchData at the end of the list.
       ManifestFetchData* existing_fetch = existing_iter->second.back().get();
-      if (existing_fetch->AddExtension(id, version.GetString(),
-                                       optional_ping_data, update_url_data,
+      if (existing_fetch->AddExtension(id,
+                                       version.GetString(),
+                                       optional_ping_data,
+                                       update_url_data,
                                        install_source,
                                        force_update)) {
         added = true;
       }
     }
     if (!added) {
       // Otherwise add a new element to the list, if the list doesn't exist or
       // if its last element is already full.
       linked_ptr<ManifestFetchData> fetch(
           CreateManifestFetchData(update_urls[i], request_id));
-      fetches_preparing_[std::make_pair(request_id, update_urls[i])].
-          push_back(fetch);
-      added = fetch->AddExtension(id, version.GetString(),
+      fetches_preparing_[std::make_pair(request_id, update_urls[i])].push_back(
+          fetch);
+      added = fetch->AddExtension(id,
+                                  version.GetString(),
                                   optional_ping_data,
                                   update_url_data,
                                   install_source,
                                   force_update);
       DCHECK(added);
     }
   }
 
   return true;
 }
 
 void ExtensionDownloader::ReportStats() const {
   UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckExtension",
                            url_stats_.extension_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckTheme",
                            url_stats_.theme_count);
-  UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckApp",
-                           url_stats_.app_count);
+  UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckApp", url_stats_.app_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckPackagedApp",
                            url_stats_.platform_app_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckPending",
                            url_stats_.pending_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckGoogleUrl",
                            url_stats_.google_url_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckOtherUrl",
                            url_stats_.other_url_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckNoUrl",
                            url_stats_.no_url_count);
@@ skipping 15 matching lines @@
       // This url is already scheduled to be fetched.
       i->Merge(*fetch_data);
       return;
     }
   }
 
   if (manifests_queue_.active_request() &&
       manifests_queue_.active_request()->full_url() == fetch_data->full_url()) {
     manifests_queue_.active_request()->Merge(*fetch_data);
   } else {
-    UMA_HISTOGRAM_COUNTS("Extensions.UpdateCheckUrlLength",
+    UMA_HISTOGRAM_COUNTS(
+        "Extensions.UpdateCheckUrlLength",
         fetch_data->full_url().possibly_invalid_spec().length());
 
     manifests_queue_.ScheduleRequest(fetch_data.Pass());
   }
 }
 
 void ExtensionDownloader::CreateManifestFetcher() {
   if (VLOG_IS_ON(2)) {
     std::vector<std::string> id_vector(
         manifests_queue_.active_request()->extension_ids().begin(),
         manifests_queue_.active_request()->extension_ids().end());
     std::string id_list = JoinString(id_vector, ',');
     VLOG(2) << "Fetching " << manifests_queue_.active_request()->full_url()
             << " for " << id_list;
   }
 
-  manifest_fetcher_.reset(net::URLFetcher::Create(
-      kManifestFetcherId, manifests_queue_.active_request()->full_url(),
-      net::URLFetcher::GET, this));
+  manifest_fetcher_.reset(
+      net::URLFetcher::Create(kManifestFetcherId,
+                              manifests_queue_.active_request()->full_url(),
+                              net::URLFetcher::GET,
+                              this));
   manifest_fetcher_->SetRequestContext(request_context_.get());
   manifest_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                                   net::LOAD_DO_NOT_SAVE_COOKIES |
                                   net::LOAD_DISABLE_CACHE);
   // Update checks can be interrupted if a network change is detected; this is
   // common for the retail mode AppPack on ChromeOS. Retrying once should be
   // enough to recover in those cases; let the fetcher retry up to 3 times
   // just in case. http://crosbug.com/130602
   manifest_fetcher_->SetAutomaticallyRetryOnNetworkChanges(3);
   manifest_fetcher_->Start();
 }
 
-void ExtensionDownloader::OnURLFetchComplete(
-    const net::URLFetcher* source) {
+void ExtensionDownloader::OnURLFetchComplete(const net::URLFetcher* source) {
   // TODO(vadimt): Remove ScopedProfile below once crbug.com/422577 is fixed.
   tracked_objects::ScopedProfile tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "422577 ExtensionDownloader::OnURLFetchComplete"));
 
   VLOG(2) << source->GetResponseCode() << " " << source->GetURL();
 
   if (source == manifest_fetcher_.get()) {
     std::string data;
     source->GetResponseAsString(&data);
@@ skipping 17 matching lines @@
     const GURL& url,
     const net::URLRequestStatus& status,
     int response_code,
     const base::TimeDelta& backoff_delay,
     const std::string& data) {
   // We want to try parsing the manifest, and if it indicates updates are
   // available, we want to fire off requests to fetch those updates.
   if (status.status() == net::URLRequestStatus::SUCCESS &&
       (response_code == 200 || (url.SchemeIsFile() && data.length() > 0))) {
     RETRY_HISTOGRAM("ManifestFetchSuccess",
-                    manifests_queue_.active_request_failure_count(), url);
+                    manifests_queue_.active_request_failure_count(),
+                    url);
     VLOG(2) << "beginning manifest parse for " << url;
-    scoped_refptr<SafeManifestParser> safe_parser(
-        new SafeManifestParser(
-            data,
-            manifests_queue_.reset_active_request().release(),
-            base::Bind(&ExtensionDownloader::HandleManifestResults,
-                       weak_ptr_factory_.GetWeakPtr())));
+    scoped_refptr<SafeManifestParser> safe_parser(new SafeManifestParser(
+        data,
+        manifests_queue_.reset_active_request().release(),
+        base::Bind(&ExtensionDownloader::HandleManifestResults,
+                   weak_ptr_factory_.GetWeakPtr())));
     safe_parser->Start();
   } else {
     VLOG(1) << "Failed to fetch manifest '" << url.possibly_invalid_spec()
             << "' response code:" << response_code;
     if (ShouldRetryRequest(status, response_code) &&
         manifests_queue_.active_request_failure_count() < kMaxRetries) {
       manifests_queue_.RetryRequest(backoff_delay);
     } else {
       RETRY_HISTOGRAM("ManifestFetchFailure",
-                      manifests_queue_.active_request_failure_count(), url);
+                      manifests_queue_.active_request_failure_count(),
+                      url);
       NotifyExtensionsDownloadFailed(
           manifests_queue_.active_request()->extension_ids(),
           manifests_queue_.active_request()->request_ids(),
           ExtensionDownloaderDelegate::MANIFEST_FETCH_FAILED);
     }
   }
   manifest_fetcher_.reset();
   manifests_queue_.reset_active_request();
 
   // If we have any pending manifest requests, fire off the next one.
@@ skipping 34 matching lines @@
 
       // Force https (crbug.com/129587).
       if (!crx_url.SchemeIsSecure()) {
         url::Replacements<char> replacements;
         std::string scheme("https");
         replacements.SetScheme(scheme.c_str(),
                                url::Component(0, scheme.size()));
         crx_url = crx_url.ReplaceComponents(replacements);
       }
     }
-    scoped_ptr<ExtensionFetch> fetch(new ExtensionFetch(
-        update->extension_id, crx_url, update->package_hash,
-        update->version, fetch_data.request_ids()));
+    scoped_ptr<ExtensionFetch> fetch(
+        new ExtensionFetch(update->extension_id,
+                           crx_url,
+                           update->package_hash,
+                           update->version,
+                           fetch_data.request_ids()));
     FetchUpdatedExtension(fetch.Pass());
   }
 
   // If the manifest response included a <daystart> element, we want to save
   // that value for any extensions which had sent a ping in the request.
   if (fetch_data.base_url().DomainIs(kGoogleDotCom) &&
       results->daystart_elapsed_seconds >= 0) {
     Time day_start =
         Time::Now() - TimeDelta::FromSeconds(results->daystart_elapsed_seconds);
 
@@ skipping 23 matching lines @@
 
     if (!fetch_data.Includes(id)) {
       VLOG(2) << "Ignoring " << id << " from this manifest";
       continue;
     }
 
     if (VLOG_IS_ON(2)) {
       if (update->version.empty())
         VLOG(2) << "manifest indicates " << id << " has no update";
       else
-        VLOG(2) << "manifest indicates " << id
-                << " latest version is '" << update->version << "'";
+        VLOG(2) << "manifest indicates " << id << " latest version is '"
+                << update->version << "'";
     }
 
     if (!delegate_->IsExtensionPending(id)) {
       // If we're not installing pending extension, and the update
       // version is the same or older than what's already installed,
       // we don't want it.
       std::string version;
       if (!delegate_->GetExtensionExistingVersion(id, &version)) {
         VLOG(2) << id << " is not installed";
         continue;
@@ skipping 21 matching lines @@
       LOG(WARNING) << "Updated version of extension " << id
                    << " available, but requires chrome version "
                    << update->browser_min_version;
       continue;
     }
     VLOG(2) << "will try to update " << id;
     result->push_back(i);
   }
 }
 
-  // Begins (or queues up) download of an updated extension.
+// Begins (or queues up) download of an updated extension.
 void ExtensionDownloader::FetchUpdatedExtension(
     scoped_ptr<ExtensionFetch> fetch_data) {
   if (!fetch_data->url.is_valid()) {
     // TODO(asargent): This can sometimes be invalid. See crbug.com/130881.
     LOG(ERROR) << "Invalid URL: '" << fetch_data->url.possibly_invalid_spec()
                << "' for extension " << fetch_data->id;
     return;
   }
 
-  for (RequestQueue<ExtensionFetch>::iterator iter =
-           extensions_queue_.begin();
-       iter != extensions_queue_.end(); ++iter) {
+  for (RequestQueue<ExtensionFetch>::iterator iter = extensions_queue_.begin();
+       iter != extensions_queue_.end();
+       ++iter) {
     if (iter->id == fetch_data->id || iter->url == fetch_data->url) {
       iter->request_ids.insert(fetch_data->request_ids.begin(),
                                fetch_data->request_ids.end());
       return;  // already scheduled
     }
   }
 
   if (extensions_queue_.active_request() &&
       extensions_queue_.active_request()->url == fetch_data->url) {
     extensions_queue_.active_request()->request_ids.insert(
@@ skipping 10 matching lines @@
     } else {
       extensions_queue_.ScheduleRequest(fetch_data.Pass());
     }
   }
 }
 
 void ExtensionDownloader::NotifyDelegateDownloadFinished(
     scoped_ptr<ExtensionFetch> fetch_data,
     const base::FilePath& crx_path,
     bool file_ownership_passed) {
-  delegate_->OnExtensionDownloadFinished(fetch_data->id, crx_path,
-      file_ownership_passed, fetch_data->url, fetch_data->version,
-      ping_results_[fetch_data->id], fetch_data->request_ids);
+  delegate_->OnExtensionDownloadFinished(fetch_data->id,
+                                         crx_path,
+                                         file_ownership_passed,
+                                         fetch_data->url,
+                                         fetch_data->version,
+                                         ping_results_[fetch_data->id],
+                                         fetch_data->request_ids);
   ping_results_.erase(fetch_data->id);
 }
 
 void ExtensionDownloader::CreateExtensionFetcher() {
   const ExtensionFetch* fetch = extensions_queue_.active_request();
   extension_fetcher_.reset(net::URLFetcher::Create(
       kExtensionFetcherId, fetch->url, net::URLFetcher::GET, this));
   extension_fetcher_->SetRequestContext(request_context_.get());
   extension_fetcher_->SetAutomaticallyRetryOnNetworkChanges(3);
 
   int load_flags = net::LOAD_DISABLE_CACHE;
   bool is_secure = fetch->url.SchemeIsSecure();
   if (fetch->credentials != ExtensionFetch::CREDENTIALS_COOKIES || !is_secure) {
-      load_flags |= net::LOAD_DO_NOT_SEND_COOKIES |
-                    net::LOAD_DO_NOT_SAVE_COOKIES;
+    load_flags |= net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES;
   }
   extension_fetcher_->SetLoadFlags(load_flags);
 
   // Download CRX files to a temp file. The blacklist is small and will be
   // processed in memory, so it is fetched into a string.
   if (fetch->id != kBlacklistAppID) {
     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_.get());
       OAuth2TokenService::ScopeSet webstore_scopes;
       webstore_scopes.insert(kWebstoreOAuth2Scope);
       access_token_request_ =
           identity_provider_->GetTokenService()->StartRequest(
-              identity_provider_->GetActiveAccountId(),
-              webstore_scopes,
-              this);
+              identity_provider_->GetActiveAccountId(), webstore_scopes, this);
       return;
     }
     extension_fetcher_->AddExtraRequestHeader(
         base::StringPrintf("%s: Bearer %s",
-            net::HttpRequestHeaders::kAuthorization,
-            access_token_.c_str()));
+                           net::HttpRequestHeaders::kAuthorization,
+                           access_token_.c_str()));
   }
 
   VLOG(2) << "Starting fetch of " << fetch->url << " for " << fetch->id;
   extension_fetcher_->Start();
 }
 
 void ExtensionDownloader::OnCRXFetchComplete(
     const net::URLFetcher* source,
     const GURL& url,
     const net::URLRequestStatus& status,
     int response_code,
     const base::TimeDelta& backoff_delay) {
   ExtensionFetch& active_request = *extensions_queue_.active_request();
   const std::string& id = active_request.id;
   if (status.status() == net::URLRequestStatus::SUCCESS &&
       (response_code == 200 || url.SchemeIsFile())) {
     RETRY_HISTOGRAM("CrxFetchSuccess",
-                    extensions_queue_.active_request_failure_count(), url);
+                    extensions_queue_.active_request_failure_count(),
+                    url);
     base::FilePath crx_path;
     // Take ownership of the file at |crx_path|.
     CHECK(source->GetResponseAsFilePath(true, &crx_path));
     scoped_ptr<ExtensionFetch> fetch_data =
         extensions_queue_.reset_active_request();
     if (extension_cache_) {
       const std::string& version = fetch_data->version;
-      extension_cache_->PutExtension(id, crx_path, version,
+      extension_cache_->PutExtension(
+          id,
+          crx_path,
+          version,
           base::Bind(&ExtensionDownloader::NotifyDelegateDownloadFinished,
                      weak_ptr_factory_.GetWeakPtr(),
                      base::Passed(&fetch_data)));
     } else {
       NotifyDelegateDownloadFinished(fetch_data.Pass(), crx_path, true);
     }
   } else if (IterateFetchCredentialsAfterFailure(
-                &active_request,
-                status,
-                response_code)) {
+                 &active_request, status, response_code)) {
     extensions_queue_.RetryRequest(backoff_delay);
   } else {
     const std::set<int>& request_ids = active_request.request_ids;
     const ExtensionDownloaderDelegate::PingResult& ping = ping_results_[id];
     VLOG(1) << "Failed to fetch extension '" << url.possibly_invalid_spec()
             << "' response code:" << response_code;
     if (ShouldRetryRequest(status, response_code) &&
         extensions_queue_.active_request_failure_count() < kMaxRetries) {
       extensions_queue_.RetryRequest(backoff_delay);
     } else {
       RETRY_HISTOGRAM("CrxFetchFailure",
-                      extensions_queue_.active_request_failure_count(), url);
+                      extensions_queue_.active_request_failure_count(),
+                      url);
       // status.error() is 0 (net::OK) or negative. (See net/base/net_errors.h)
       UMA_HISTOGRAM_SPARSE_SLOWLY("Extensions.CrxFetchError", -status.error());
       delegate_->OnExtensionDownloadFailed(
           id, ExtensionDownloaderDelegate::CRX_FETCH_FAILED, ping, request_ids);
     }
     ping_results_.erase(id);
     extensions_queue_.reset_active_request();
   }
 
   extension_fetcher_.reset();
 
   // If there are any pending downloads left, start the next one.
   extensions_queue_.StartNextRequest();
 }
 
 void ExtensionDownloader::NotifyExtensionsDownloadFailed(
     const std::set<std::string>& extension_ids,
     const std::set<int>& request_ids,
     ExtensionDownloaderDelegate::Error error) {
   for (std::set<std::string>::const_iterator it = extension_ids.begin();
-       it != extension_ids.end(); ++it) {
+       it != extension_ids.end();
+       ++it) {
     const ExtensionDownloaderDelegate::PingResult& ping = ping_results_[*it];
     delegate_->OnExtensionDownloadFailed(*it, error, ping, request_ids);
     ping_results_.erase(*it);
   }
 }
 
 void ExtensionDownloader::NotifyUpdateFound(const std::string& id,
                                             const std::string& version) {
   UpdateDetails updateInfo(id, Version(version));
   content::NotificationService::current()->Notify(
@@ skipping 35 matching lines @@
         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
       // doesn't have access to this resource, or the server keeps returning
       // 401s and we've retried too many times. Fall back on cookies.
-      if (access_token_.empty() ||
-          response_code == net::HTTP_FORBIDDEN ||
+      if (access_token_.empty() || response_code == net::HTTP_FORBIDDEN ||
           fetch->oauth2_attempt_count > kMaxOAuth2Attempts) {
         fetch->credentials = ExtensionFetch::CREDENTIALS_COOKIES;
         return true;
       }
       // Something else is wrong. Time to give up.
       return false;
     case ExtensionFetch::CREDENTIALS_COOKIES:
       if (response_code == net::HTTP_FORBIDDEN) {
         // Try the next session identity, up to some maximum.
         return IncrementAuthUserIndex(&fetch->url);
       }
       return false;
     default:
       NOTREACHED();
   }
   NOTREACHED();
   return false;
 }
 
 void ExtensionDownloader::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
   access_token_ = access_token;
   extension_fetcher_->AddExtraRequestHeader(
       base::StringPrintf("%s: Bearer %s",
-          net::HttpRequestHeaders::kAuthorization,
-          access_token_.c_str()));
+                         net::HttpRequestHeaders::kAuthorization,
+                         access_token_.c_str()));
   extension_fetcher_->Start();
 }
 
 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();
 }
 
 ManifestFetchData* ExtensionDownloader::CreateManifestFetchData(
     const GURL& update_url,
     int request_id) {
   ManifestFetchData::PingMode ping_mode = ManifestFetchData::NO_PING;
   if (update_url.DomainIs(ping_enabled_domain_.c_str())) {
     if (enable_extra_update_metrics_) {
       ping_mode = ManifestFetchData::PING_WITH_METRICS;
     } else {
       ping_mode = ManifestFetchData::PING;
     }
   }
   return new ManifestFetchData(
       update_url, request_id, brand_code_, manifest_query_params_, ping_mode);
 }
 
 }  // namespace extensions