Reland: Factor Chrome details out of update manifest fetching.

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 169 matching lines @@
     : 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() {}
 
 bool ExtensionDownloader::AddExtension(const Extension& extension,
                                        int request_id) {
   // Skip extensions with empty update URLs converted from user
@@ skipping 67 matching lines @@
   fetches_preparing_.clear();
 }
 
 void ExtensionDownloader::StartBlacklistUpdate(
     const std::string& version,
     const ManifestFetchData::PingData& ping_data,
     int request_id) {
   // Note: it is very important that we use the https version of the update
   // url here to avoid DNS hijacking of the blacklist, which is not validated
   // by a public key signature like .crx files are.
-  scoped_ptr<ManifestFetchData> blacklist_fetch(
-      new ManifestFetchData(extension_urls::GetWebstoreUpdateUrl(),
-                            request_id));
+  scoped_ptr<ManifestFetchData> blacklist_fetch(CreateManifestFetchData(
+      extension_urls::GetWebstoreUpdateUrl(), request_id));
   DCHECK(blacklist_fetch->base_url().SchemeIsSecure());
   blacklist_fetch->AddExtension(kBlacklistAppID,
                                 version,
                                 &ping_data,
                                 std::string(),
                                 kDefaultInstallSource,
                                 false);
   StartUpdateCheck(blacklist_fetch.Pass());
 }
 
@@ skipping 56 matching lines @@
       ++url_stats_.platform_app_count;
       break;
     case Manifest::TYPE_UNKNOWN:
     default:
       ++url_stats_.pending_count;
       break;
   }
 
   std::vector<GURL> update_urls;
   update_urls.push_back(update_url);
-  // If UMA is enabled, also add to ManifestFetchData for the
+  // If metrics are enabled, also add to ManifestFetchData for the
   // webstore update URL.
   if (!extension_urls::IsWebstoreUpdateUrl(update_url) &&
-      ChromeMetricsServiceAccessor::IsMetricsReportingEnabled()) {
+      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;
     if (!install_source_override.empty()) {
@@ skipping 17 matching lines @@
                                        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(
-          new ManifestFetchData(update_urls[i], request_id));
+          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(),
                                   optional_ping_data,
                                   update_url_data,
                                   install_source,
                                   force_update);
       DCHECK(added);
     }
   }
@@ skipping 533 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();
 }
 
+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