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 67 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)
@@ skipping 20 matching lines @@
   request_sender_->Send(
       config_->UseCupSigning(),
       BuildUpdateCheckRequest(*config_, items_to_check, additional_attributes),
       config_->UpdateUrl(),
       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