Decompose //extensions/browser/BUILD.gn

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 <stddef.h>
 
 #include <utility>
 
@@ skipping 108 matching lines @@
 
 // This parses and updates a URL query such that the value of the |authuser|
 // query parameter is incremented by 1. If parameter was not present in the URL,
 // it will be added with a value of 1. All other query keys and values are
 // preserved as-is. Returns |false| if the user index exceeds a hard-coded
 // maximum.
 bool IncrementAuthUserIndex(GURL* url) {
   int user_index = 0;
   std::string old_query = url->query();
   std::vector<std::string> new_query_parts;
-  url::Component query(0, old_query.length());
+  url::Component query(0, static_cast<int>(old_query.length()));
   url::Component key, value;
   while (url::ExtractQueryKeyValue(old_query.c_str(), &query, &key, &value)) {
     std::string key_string = old_query.substr(key.begin, key.len);
     std::string value_string = old_query.substr(value.begin, value.len);
     if (key_string == kAuthUserQueryKey) {
       base::StringToInt(value_string, &user_index);
     } else {
       new_query_parts.push_back(base::StringPrintf(
           "%s=%s", key_string.c_str(), value_string.c_str()));
     }
   }
   if (user_index >= kMaxAuthUserValue)
     return false;
   new_query_parts.push_back(
       base::StringPrintf("%s=%d", kAuthUserQueryKey, user_index + 1));
   std::string new_query_string = base::JoinString(new_query_parts, "&");
-  url::Component new_query(0, new_query_string.size());
+  url::Component new_query(0, static_cast<int>(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 base::Version& version)
@@ skipping 279 matching lines @@
       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",
-        fetch_data->full_url().possibly_invalid_spec().length());
+        static_cast<int>(
+            fetch_data->full_url().possibly_invalid_spec().length()));
 
     manifests_queue_.ScheduleRequest(std::move(fetch_data));
   }
 }
 
 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());
@@ skipping 114 matching lines @@
     } 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.SchemeIsCryptographic()) {
         url::Replacements<char> replacements;
         std::string scheme("https");
-        replacements.SetScheme(scheme.c_str(),
-                               url::Component(0, scheme.size()));
+        replacements.SetScheme(
+            scheme.c_str(), url::Component(0, static_cast<int>(scheme.size())));
         crx_url = crx_url.ReplaceComponents(replacements);
       }
     }
     std::unique_ptr<ExtensionFetch> fetch(
         new ExtensionFetch(update->extension_id, crx_url, update->package_hash,
                            update->version, fetch_data->request_ids()));
     FetchUpdatedExtension(std::move(fetch));
   }
 
   // If the manifest response included a <daystart> element, we want to save
@@ skipping 64 matching lines @@
         !ExtensionsBrowserClient::Get()->IsMinBrowserVersionSupported(
             update->browser_min_version)) {
       // TODO(asargent) - We may want this to show up in the extensions UI
       // eventually. (http://crbug.com/12547).
       DLOG(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);
+    result->push_back(static_cast<int>(i));
   }
 }
 
 // Begins (or queues up) download of an updated extension.
 void ExtensionDownloader::FetchUpdatedExtension(
     std::unique_ptr<ExtensionFetch> fetch_data) {
   if (!fetch_data->url.is_valid()) {
     // TODO(asargent): This can sometimes be invalid. See crbug.com/130881.
     DLOG(WARNING) << "Invalid URL: '" << fetch_data->url.possibly_invalid_spec()
                   << "' for extension " << fetch_data->id;
@@ skipping 274 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