Allow fallback from https to http for component update checks.

components/update_client/update_checker.cc

 // Copyright 2014 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 "components/update_client/update_checker.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
@@ skipping 15 matching lines @@
 
 namespace update_client {
 
 namespace {
 
 // Returns a sanitized version of the brand or an empty string otherwise.
 std::string SanitizeBrand(const std::string& brand) {
   return IsValidBrand(brand) ? brand : std::string("");
 }
 
+// Returns true if at least one item requires network encryption.
+bool IsEncryptionRequired(const std::vector<CrxUpdateItem*>& items) {
+  for (const auto& item : items) {
+    if (item->component.requires_network_encryption)
+      return true;
+  }
+  return false;
+}
+
 // Builds an update check request for |components|. |additional_attributes| is
 // serialized as part of the <request> element of the request to customize it
 // with data that is not platform or component specific. For each |item|, a
 // corresponding <app> element is created and inserted as a child node of
 // the <request>.
 //
 // An app element looks like this:
 //    <app appid="hnimpnehoodheedghdeeijklkeaacbdc"
 //         version="0.1.2.3" installsource="ondemand">
 //      <updatecheck />
@@ skipping 40 matching lines @@
   explicit UpdateCheckerImpl(const scoped_refptr<Configurator>& config);
   ~UpdateCheckerImpl() override;
 
   // Overrides for UpdateChecker.
   bool CheckForUpdates(
       const std::vector<CrxUpdateItem*>& items_to_check,
       const std::string& additional_attributes,
       const UpdateCheckCallback& update_check_callback) override;
 
  private:
-  void OnRequestSenderComplete(int error, const std::string& response);
+  void OnRequestSenderComplete(int error,
+                               const std::string& response,
+                               int retry_after_sec);
   base::ThreadChecker thread_checker_;
 
   const scoped_refptr<Configurator> config_;
   UpdateCheckCallback update_check_callback_;
   scoped_ptr<RequestSender> request_sender_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateCheckerImpl);
 };
 
 UpdateCheckerImpl::UpdateCheckerImpl(const scoped_refptr<Configurator>& config)
     : config_(config) {}
 
 UpdateCheckerImpl::~UpdateCheckerImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 bool UpdateCheckerImpl::CheckForUpdates(
     const std::vector<CrxUpdateItem*>& items_to_check,
     const std::string& additional_attributes,
     const UpdateCheckCallback& update_check_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (request_sender_.get()) {
     NOTREACHED();
     return false;  // Another update check is in progress.
   }
 
   update_check_callback_ = update_check_callback;
 
+  auto urls(config_->UpdateUrl());
+  if (IsEncryptionRequired(items_to_check))
+    RemoveUnsecureUrls(&urls);
+
   request_sender_.reset(new RequestSender(config_));
   request_sender_->Send(
       config_->UseCupSigning(),
       BuildUpdateCheckRequest(*config_, items_to_check, additional_attributes),
-      config_->UpdateUrl(),
-      base::Bind(&UpdateCheckerImpl::OnRequestSenderComplete,
-                 base::Unretained(this)));
+      urls, base::Bind(&UpdateCheckerImpl::OnRequestSenderComplete,
+                       base::Unretained(this)));
   return true;
 }
 
 void UpdateCheckerImpl::OnRequestSenderComplete(int error,
-                                                const std::string& response) {
+                                                const std::string& response,
+                                                int retry_after_sec) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!error) {
     UpdateResponse update_response;
     if (update_response.Parse(response)) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE,
-          base::Bind(update_check_callback_, error, update_response.results()));
+          FROM_HERE, base::Bind(update_check_callback_, error,
+                                update_response.results(), retry_after_sec));
       return;
     }
 
     error = -1;
     VLOG(1) << "Parse failed " << update_response.errors();
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE,
-      base::Bind(update_check_callback_, error, UpdateResponse::Results()));
+      FROM_HERE, base::Bind(update_check_callback_, error,
+                            UpdateResponse::Results(), retry_after_sec));
 }
 
 }  // namespace
 
 scoped_ptr<UpdateChecker> UpdateChecker::Create(
     const scoped_refptr<Configurator>& config) {
   return scoped_ptr<UpdateChecker>(new UpdateCheckerImpl(config));
 }
 
 }  // namespace update_client