Allow fallback from https to http for component update checks.

components/update_client/update_client_unittest.cc

 // Copyright 2015 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 <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 79 matching lines @@
     EXPECT_TRUE(update_client_->GetCrxUpdateState(id, &update_item));
     EXPECT_EQ(update_item.on_demand, expected_value_);
   }
 }
 
 class FakePingManagerImpl : public PingManager {
  public:
   explicit FakePingManagerImpl(const scoped_refptr<Configurator>& config);
   ~FakePingManagerImpl() override;
 
-  void SendPing(const CrxUpdateItem* item) override;
+  bool SendPing(const CrxUpdateItem* item) override;
 
   const std::vector<CrxUpdateItem>& items() const;
 
  private:
   std::vector<CrxUpdateItem> items_;
   DISALLOW_COPY_AND_ASSIGN(FakePingManagerImpl);
 };
 
 FakePingManagerImpl::FakePingManagerImpl(
     const scoped_refptr<Configurator>& config)
     : PingManager(config) {}
 
 FakePingManagerImpl::~FakePingManagerImpl() {
 }
 
-void FakePingManagerImpl::SendPing(const CrxUpdateItem* item) {
+bool FakePingManagerImpl::SendPing(const CrxUpdateItem* item) {
   items_.push_back(*item);
+  return true;
 }
 
 const std::vector<CrxUpdateItem>& FakePingManagerImpl::items() const {
   return items_;
 }
 
 }  // namespace
 
 using ::testing::_;
 using ::testing::AnyNumber;
@@ skipping 92 matching lines @@
         const scoped_refptr<Configurator>& config) {
       return scoped_ptr<UpdateChecker>(new FakeUpdateChecker());
     }
 
     bool CheckForUpdates(
         const std::vector<CrxUpdateItem*>& items_to_check,
         const std::string& additional_attributes,
         const UpdateCheckCallback& update_check_callback) override {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
-          base::Bind(update_check_callback, 0, UpdateResponse::Results()));
+          base::Bind(update_check_callback, 0, UpdateResponse::Results(), 0));
       return true;
     }
   };
 
   class FakeCrxDownloader : public CrxDownloader {
    public:
     static scoped_ptr<CrxDownloader> Create(
         bool is_background_download,
         net::URLRequestContextGetter* context_getter,
         const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
@@ skipping 120 matching lines @@
       result.extension_id = "jebgalgnebhfojomionfpkfelancnnkf";
       result.crx_urls.push_back(GURL("http://localhost/download/"));
       result.manifest.version = "1.0";
       result.manifest.browser_min_version = "11.0.1.0";
       result.manifest.packages.push_back(package);
 
       UpdateResponse::Results results;
       results.list.push_back(result);
 
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(update_check_callback, 0, results));
+          FROM_HERE, base::Bind(update_check_callback, 0, results, 0));
       return true;
     }
   };
 
   class FakeCrxDownloader : public CrxDownloader {
    public:
     static scoped_ptr<CrxDownloader> Create(
         bool is_background_download,
         net::URLRequestContextGetter* context_getter,
         const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
@@ skipping 191 matching lines @@
       result2.crx_urls.push_back(GURL("http://localhost/download/"));
       result2.manifest.version = "1.0";
       result2.manifest.browser_min_version = "11.0.1.0";
       result2.manifest.packages.push_back(package2);
 
       UpdateResponse::Results results;
       results.list.push_back(result1);
       results.list.push_back(result2);
 
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(update_check_callback, 0, results));
+          FROM_HERE, base::Bind(update_check_callback, 0, results, 0));
       return true;
     }
   };
 
   class FakeCrxDownloader : public CrxDownloader {
    public:
     static scoped_ptr<CrxDownloader> Create(
         bool is_background_download,
         net::URLRequestContextGetter* context_getter,
         const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
@@ skipping 226 matching lines @@
       result2.crx_urls.push_back(GURL("http://localhost/download/"));
       result2.manifest.version = "1.0";
       result2.manifest.browser_min_version = "11.0.1.0";
       result2.manifest.packages.push_back(package2);
 
       UpdateResponse::Results results;
       results.list.push_back(result1);
       results.list.push_back(result2);
 
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(update_check_callback, 0, results));
+          FROM_HERE, base::Bind(update_check_callback, 0, results, 0));
       return true;
     }
   };
 
   class FakeCrxDownloader : public CrxDownloader {
    public:
     static scoped_ptr<CrxDownloader> Create(
         bool is_background_download,
         net::URLRequestContextGetter* context_getter,
         const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
@@ skipping 251 matching lines @@
         result.crx_diffurls.push_back(GURL("http://localhost/download/"));
         result.manifest.version = "2.0";
         result.manifest.browser_min_version = "11.0.1.0";
         result.manifest.packages.push_back(package);
         results.list.push_back(result);
       } else {
         NOTREACHED();
       }
 
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(update_check_callback, 0, results));
+          FROM_HERE, base::Bind(update_check_callback, 0, results, 0));
       return true;
     }
   };
 
   class FakeCrxDownloader : public CrxDownloader {
    public:
     static scoped_ptr<CrxDownloader> Create(
         bool is_background_download,
         net::URLRequestContextGetter* context_getter,
         const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
@@ skipping 220 matching lines @@
       result.extension_id = "jebgalgnebhfojomionfpkfelancnnkf";
       result.crx_urls.push_back(GURL("http://localhost/download/"));
       result.manifest.version = "1.0";
       result.manifest.browser_min_version = "11.0.1.0";
       result.manifest.packages.push_back(package);
 
       UpdateResponse::Results results;
       results.list.push_back(result);
 
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(update_check_callback, 0, results));
+          FROM_HERE, base::Bind(update_check_callback, 0, results, 0));
       return true;
     }
   };
 
   class FakeCrxDownloader : public CrxDownloader {
    public:
     static scoped_ptr<CrxDownloader> Create(
         bool is_background_download,
         net::URLRequestContextGetter* context_getter,
         const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
@@ skipping 212 matching lines @@
         result.crx_diffurls.push_back(GURL("http://localhost/download/"));
         result.manifest.version = "2.0";
         result.manifest.browser_min_version = "11.0.1.0";
         result.manifest.packages.push_back(package);
         results.list.push_back(result);
       } else {
         NOTREACHED();
       }
 
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(update_check_callback, 0, results));
+          FROM_HERE, base::Bind(update_check_callback, 0, results, 0));
       return true;
     }
   };
 
   class FakeCrxDownloader : public CrxDownloader {
    public:
     static scoped_ptr<CrxDownloader> Create(
         bool is_background_download,
         net::URLRequestContextGetter* context_getter,
         const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
@@ skipping 184 matching lines @@
         const scoped_refptr<Configurator>& config) {
       return scoped_ptr<UpdateChecker>(new FakeUpdateChecker());
     }
 
     bool CheckForUpdates(
         const std::vector<CrxUpdateItem*>& items_to_check,
         const std::string& additional_attributes,
         const UpdateCheckCallback& update_check_callback) override {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
-          base::Bind(update_check_callback, 0, UpdateResponse::Results()));
+          base::Bind(update_check_callback, 0, UpdateResponse::Results(), 0));
       return true;
     }
   };
 
   class FakeCrxDownloader : public CrxDownloader {
    public:
     static scoped_ptr<CrxDownloader> Create(
         bool is_background_download,
         net::URLRequestContextGetter* context_getter,
         const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
@@ skipping 112 matching lines @@
       result.extension_id = "jebgalgnebhfojomionfpkfelancnnkf";
       result.crx_urls.push_back(GURL("http://localhost/download/"));
       result.manifest.version = "1.0";
       result.manifest.browser_min_version = "11.0.1.0";
       result.manifest.packages.push_back(package);
 
       UpdateResponse::Results results;
       results.list.push_back(result);
 
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(update_check_callback, 0, results));
+          FROM_HERE, base::Bind(update_check_callback, 0, results, 0));
       return true;
     }
   };
 
   class FakeCrxDownloader : public CrxDownloader {
    public:
     static scoped_ptr<CrxDownloader> Create(
         bool is_background_download,
         net::URLRequestContextGetter* context_getter,
         const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
@@ skipping 131 matching lines @@
         const scoped_refptr<Configurator>& config) {
       return scoped_ptr<UpdateChecker>(new FakeUpdateChecker());
     }
 
     bool CheckForUpdates(
         const std::vector<CrxUpdateItem*>& items_to_check,
         const std::string& additional_attributes,
         const UpdateCheckCallback& update_check_callback) override {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
-          base::Bind(update_check_callback, 0, UpdateResponse::Results()));
+          base::Bind(update_check_callback, 0, UpdateResponse::Results(), 0));
       return true;
     }
   };
 
   class FakeCrxDownloader : public CrxDownloader {
    public:
     static scoped_ptr<CrxDownloader> Create(
         bool is_background_download,
         net::URLRequestContextGetter* context_getter,
         const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
@@ skipping 159 matching lines @@
 
   scoped_ptr<PingManager> ping_manager(new FakePingManager(config()));
   scoped_refptr<UpdateClient> update_client(new UpdateClientImpl(
       config(), std::move(ping_manager), &FakeUpdateChecker::Create,
       &FakeCrxDownloader::Create));
 
   update_client->SendUninstallPing("jebgalgnebhfojomionfpkfelancnnkf",
                                    base::Version("1.0"), 10);
 }
 
+TEST_F(UpdateClientTest, RetryAfter) {
+  class DataCallbackFake {
+   public:
+    static void Callback(const std::vector<std::string>& ids,
+                         std::vector<CrxComponent>* components) {
+      CrxComponent crx;
+      crx.name = "test_jebg";
+      crx.pk_hash.assign(jebg_hash, jebg_hash + arraysize(jebg_hash));
+      crx.version = Version("0.9");
+      crx.installer = new TestInstaller;
+      components->push_back(crx);
+    }
+  };
+
+  class CompletionCallbackFake {
+   public:
+    static void Callback(const base::Closure& quit_closure, int error) {
+      static int num_call = 0;
+      ++num_call;
+
+      EXPECT_LE(num_call, 4);
+
+      if (num_call == 1) {
+        EXPECT_EQ(0, error);
+      } else if (num_call == 2) {
+        // This request is throttled since the update engine received a
+        // positive |retry_after_sec| value in the update check response.
+        EXPECT_EQ(Error::ERROR_UPDATE_RETRY_LATER, error);
+      } else if (num_call == 3) {
+        // This request is a foreground Install, which is never throttled.
+        // The update engine received a |retry_after_sec| value of 0, which
+        // resets the throttling.
+        EXPECT_EQ(0, error);
+      } else if (num_call == 4) {
+        // This request succeeds since there is no throttling in effect.
+        EXPECT_EQ(0, error);
+      }
+
+      quit_closure.Run();
+    }
+  };
+
+  class FakeUpdateChecker : public UpdateChecker {
+   public:
+    static scoped_ptr<UpdateChecker> Create(
+        const scoped_refptr<Configurator>& config) {
+      return scoped_ptr<UpdateChecker>(new FakeUpdateChecker());
+    }
+
+    bool CheckForUpdates(
+        const std::vector<CrxUpdateItem*>& items_to_check,
+        const std::string& additional_attributes,
+        const UpdateCheckCallback& update_check_callback) override {
+      static int num_call = 0;
+      ++num_call;
+
+      EXPECT_LE(num_call, 3);
+
+      int retry_after_sec(0);
+      if (num_call == 1) {
+        // Throttle the next call.
+        retry_after_sec = 60 * 60;  // 1 hour.
+      }
+
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE, base::Bind(update_check_callback, 0,
+                                UpdateResponse::Results(), retry_after_sec));
+      return true;
+    }
+  };
+
+  class FakeCrxDownloader : public CrxDownloader {
+   public:
+    static scoped_ptr<CrxDownloader> Create(
+        bool is_background_download,
+        net::URLRequestContextGetter* context_getter,
+        const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
+      return scoped_ptr<CrxDownloader>(new FakeCrxDownloader());
+    }
+
+   private:
+    FakeCrxDownloader()
+        : CrxDownloader(base::ThreadTaskRunnerHandle::Get(), nullptr) {}
+    ~FakeCrxDownloader() override {}
+
+    void DoStartDownload(const GURL& url) override { EXPECT_TRUE(false); }
+  };
+
+  class FakePingManager : public FakePingManagerImpl {
+   public:
+    explicit FakePingManager(const scoped_refptr<Configurator>& config)
+        : FakePingManagerImpl(config) {}
+    ~FakePingManager() override { EXPECT_TRUE(items().empty()); }
+  };
+
+  scoped_ptr<PingManager> ping_manager(new FakePingManager(config()));
+  scoped_refptr<UpdateClient> update_client(new UpdateClientImpl(
+      config(), std::move(ping_manager), &FakeUpdateChecker::Create,
+      &FakeCrxDownloader::Create));
+
+  MockObserver observer;
+
+  InSequence seq;
+  EXPECT_CALL(observer, OnEvent(Events::COMPONENT_CHECKING_FOR_UPDATES,
+                                "jebgalgnebhfojomionfpkfelancnnkf"))
+      .Times(1);
+  EXPECT_CALL(observer, OnEvent(Events::COMPONENT_NOT_UPDATED,
+                                "jebgalgnebhfojomionfpkfelancnnkf"))
+      .Times(1);
+  EXPECT_CALL(observer, OnEvent(Events::COMPONENT_CHECKING_FOR_UPDATES,
+                                "jebgalgnebhfojomionfpkfelancnnkf"))
+      .Times(1);
+  EXPECT_CALL(observer, OnEvent(Events::COMPONENT_NOT_UPDATED,
+                                "jebgalgnebhfojomionfpkfelancnnkf"))
+      .Times(1);
+  EXPECT_CALL(observer, OnEvent(Events::COMPONENT_CHECKING_FOR_UPDATES,
+                                "jebgalgnebhfojomionfpkfelancnnkf"))
+      .Times(1);
+  EXPECT_CALL(observer, OnEvent(Events::COMPONENT_NOT_UPDATED,
+                                "jebgalgnebhfojomionfpkfelancnnkf"))
+      .Times(1);
+
+  update_client->AddObserver(&observer);
+
+  std::vector<std::string> ids;
+  ids.push_back(std::string("jebgalgnebhfojomionfpkfelancnnkf"));
+
+  {
+    // The engine handles this Update call but responds with a valid
+    // |retry_after_sec|, which causes subsequent calls to fail.
+    base::RunLoop runloop;
+    update_client->Update(
+        ids, base::Bind(&DataCallbackFake::Callback),
+        base::Bind(&CompletionCallbackFake::Callback, runloop.QuitClosure()));
+    runloop.Run();
+  }
+
+  {
+    // This call will result in a completion callback invoked with
+    // Error::ERROR_UPDATE_RETRY_LATER.
+    base::RunLoop runloop;
+    update_client->Update(
+        ids, base::Bind(&DataCallbackFake::Callback),
+        base::Bind(&CompletionCallbackFake::Callback, runloop.QuitClosure()));
+    runloop.Run();
+  }
+
+  {
+    // The Install call is handled, and the throttling is reset due to
+    // the value of |retry_after_sec| in the completion callback.
+    base::RunLoop runloop;
+    update_client->Install(
+        std::string("jebgalgnebhfojomionfpkfelancnnkf"),
+        base::Bind(&DataCallbackFake::Callback),
+        base::Bind(&CompletionCallbackFake::Callback, runloop.QuitClosure()));
+    runloop.Run();
+  }
+
+  {
+    // This call succeeds.
+    base::RunLoop runloop;
+    update_client->Update(
+        ids, base::Bind(&DataCallbackFake::Callback),
+        base::Bind(&CompletionCallbackFake::Callback, runloop.QuitClosure()));
+    runloop.Run();
+  }
+
+  update_client->RemoveObserver(&observer);
+}
+
 }  // namespace update_client