Remove ManifestFetchData parameter from SafeManifestParser

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 "extensions/browser/updater/extension_downloader.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 510 matching lines @@
   // 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);
     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())));
+        base::Bind(
+            &ExtensionDownloader::HandleManifestResults,
+            weak_ptr_factory_.GetWeakPtr(),
+            base::Owned(manifests_queue_.reset_active_request().release()))));
     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);
       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.
   manifests_queue_.StartNextRequest();
 }
 
 void ExtensionDownloader::HandleManifestResults(
-    const ManifestFetchData& fetch_data,
+    const ManifestFetchData* fetch_data,
     const UpdateManifest::Results* results) {
   // Keep a list of extensions that will not be updated, so that the |delegate_|
   // can be notified once we're done here.
-  std::set<std::string> not_updated(fetch_data.extension_ids());
+  std::set<std::string> not_updated(fetch_data->extension_ids());
 
   if (!results) {
+    VLOG(2) << "parsing manifest failed (" << fetch_data->full_url() << ")";
     NotifyExtensionsDownloadFailed(
-        not_updated,
-        fetch_data.request_ids(),
+        not_updated, fetch_data->request_ids(),
         ExtensionDownloaderDelegate::MANIFEST_INVALID);
     return;
+  } else {
+    VLOG(2) << "parsing manifest succeeded (" << fetch_data->full_url() << ")";
   }
 
   // Examine the parsed manifest and kick off fetches of any new crx files.
   std::vector<int> updates;
-  DetermineUpdates(fetch_data, *results, &updates);
+  DetermineUpdates(*fetch_data, *results, &updates);
   for (size_t i = 0; i < updates.size(); i++) {
     const UpdateManifest::Result* update = &(results->list.at(updates[i]));
     const std::string& id = update->extension_id;
     not_updated.erase(id);
 
     GURL crx_url = update->crx_url;
     if (id != kBlacklistAppID) {
       NotifyUpdateFound(update->extension_id, update->version);
     } else {
       // The URL of the blacklist file is returned by the server and we need to
       // be sure that we continue to be able to reliably detect whether a URL
       // references a blacklist file.
       DCHECK(extension_urls::IsBlacklistUpdateUrl(crx_url)) << crx_url;
 
       // 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()));
+        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) &&
+  if (fetch_data->base_url().DomainIs(kGoogleDotCom) &&
       results->daystart_elapsed_seconds >= 0) {
     Time day_start =
         Time::Now() - TimeDelta::FromSeconds(results->daystart_elapsed_seconds);
 
-    const std::set<std::string>& extension_ids = fetch_data.extension_ids();
+    const std::set<std::string>& extension_ids = fetch_data->extension_ids();
     std::set<std::string>::const_iterator i;
     for (i = extension_ids.begin(); i != extension_ids.end(); i++) {
       const std::string& id = *i;
       ExtensionDownloaderDelegate::PingResult& result = ping_results_[id];
-      result.did_ping = fetch_data.DidPing(id, ManifestFetchData::ROLLCALL);
+      result.did_ping = fetch_data->DidPing(id, ManifestFetchData::ROLLCALL);
       result.day_start = day_start;
     }
   }
 
   NotifyExtensionsDownloadFailed(
-      not_updated,
-      fetch_data.request_ids(),
+      not_updated, fetch_data->request_ids(),
       ExtensionDownloaderDelegate::NO_UPDATE_AVAILABLE);
 }
 
 void ExtensionDownloader::DetermineUpdates(
     const ManifestFetchData& fetch_data,
     const UpdateManifest::Results& possible_updates,
     std::vector<int>* result) {
   for (size_t i = 0; i < possible_updates.list.size(); i++) {
     const UpdateManifest::Result* update = &possible_updates.list[i];
     const std::string& id = update->extension_id;
@@ skipping 311 matching lines @@
     const GURL& update_url,
     int request_id) {
   ManifestFetchData::PingMode ping_mode = ManifestFetchData::NO_PING;
   if (update_url.DomainIs(ping_enabled_domain_.c_str()))
     ping_mode = ManifestFetchData::PING_WITH_ENABLED_STATE;
   return new ManifestFetchData(
       update_url, request_id, brand_code_, manifest_query_params_, ping_mode);
 }
 
 }  // namespace extensions