Add module for counting date-last-roll-call and persisting those counts

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"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/test/sequenced_worker_pool_owner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "base/version.h"
+#include "components/prefs/testing_pref_service.h"
 #include "components/update_client/crx_update_item.h"
+#include "components/update_client/persisted_data.h"
 #include "components/update_client/ping_manager.h"
 #include "components/update_client/test_configurator.h"
 #include "components/update_client/test_installer.h"
 #include "components/update_client/update_checker.h"
 #include "components/update_client/update_client_internal.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace update_client {
@@ skipping 106 matching lines @@
   UpdateClientTest();
   ~UpdateClientTest() override;
 
  protected:
   void RunThreads();
 
   // Returns the full path to a test file.
   static base::FilePath TestFilePath(const char* file);
 
   scoped_refptr<update_client::Configurator> config() { return config_; }
+  const update_client::PersistedData& metadata() { return *metadata_; }
 
   base::Closure quit_closure() { return quit_closure_; }
 
  private:
   static const int kNumWorkerThreads_ = 2;
 
   base::MessageLoopForUI message_loop_;
   base::RunLoop runloop_;
   base::Closure quit_closure_;
 
   scoped_ptr<base::SequencedWorkerPoolOwner> worker_pool_;
 
   scoped_refptr<update_client::Configurator> config_;
+  std::unique_ptr<TestingPrefServiceSimple> pref_;
+  std::unique_ptr<update_client::PersistedData> metadata_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateClientTest);
 };
 
 UpdateClientTest::UpdateClientTest()
     : worker_pool_(
           new base::SequencedWorkerPoolOwner(kNumWorkerThreads_, "test")) {
   quit_closure_ = runloop_.QuitClosure();
 
   auto pool = worker_pool_->pool();
   config_ = new TestConfigurator(
       pool->GetSequencedTaskRunner(pool->GetSequenceToken()),
       message_loop_.task_runner());
+  pref_.reset(new TestingPrefServiceSimple());
+  PersistedData::RegisterPrefs(pref_->registry());
+  metadata_.reset(new PersistedData(pref_.get()));
 }
 
 UpdateClientTest::~UpdateClientTest() {
 }
 
 void UpdateClientTest::RunThreads() {
   runloop_.Run();
 }
 
 base::FilePath UpdateClientTest::TestFilePath(const char* file) {
@@ skipping 26 matching lines @@
    public:
     static void Callback(const base::Closure& quit_closure, int error) {
       EXPECT_EQ(0, error);
       quit_closure.Run();
     }
   };
 
   class FakeUpdateChecker : public UpdateChecker {
    public:
     static scoped_ptr<UpdateChecker> Create(
-        const scoped_refptr<Configurator>& config) {
+        const scoped_refptr<Configurator>& config,
+        const PersistedData& metadata) {
       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(), 0));
@@ skipping 85 matching lines @@
    public:
     static void Callback(const base::Closure& quit_closure, int error) {
       EXPECT_EQ(0, error);
       quit_closure.Run();
     }
   };
 
   class FakeUpdateChecker : public UpdateChecker {
    public:
     static scoped_ptr<UpdateChecker> Create(
-        const scoped_refptr<Configurator>& config) {
+        const scoped_refptr<Configurator>& config,
+        const PersistedData& metadata) {
       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 {
       /*
       Fake the following response:
 
@@ skipping 164 matching lines @@
    public:
     static void Callback(const base::Closure& quit_closure, int error) {
       EXPECT_EQ(0, error);
       quit_closure.Run();
     }
   };
 
   class FakeUpdateChecker : public UpdateChecker {
    public:
     static scoped_ptr<UpdateChecker> Create(
-        const scoped_refptr<Configurator>& config) {
+        const scoped_refptr<Configurator>& config,
+        const PersistedData& metadata) {
       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 {
       /*
       Fake the following response:
 
@@ skipping 226 matching lines @@
    public:
     static void Callback(const base::Closure& quit_closure, int error) {
       EXPECT_EQ(0, error);
       quit_closure.Run();
     }
   };
 
   class FakeUpdateChecker : public UpdateChecker {
    public:
     static scoped_ptr<UpdateChecker> Create(
-        const scoped_refptr<Configurator>& config) {
+        const scoped_refptr<Configurator>& config,
+        const PersistedData& metadata) {
       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 {
       /*
       Fake the following response:
 
@@ skipping 229 matching lines @@
    public:
     static void Callback(const base::Closure& quit_closure, int error) {
       EXPECT_EQ(0, error);
       quit_closure.Run();
     }
   };
 
   class FakeUpdateChecker : public UpdateChecker {
    public:
     static scoped_ptr<UpdateChecker> Create(
-        const scoped_refptr<Configurator>& config) {
+        const scoped_refptr<Configurator>& config,
+        const PersistedData& metadata) {
       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;
 
@@ skipping 270 matching lines @@
    public:
     static void Callback(const base::Closure& quit_closure, int error) {
       EXPECT_EQ(0, error);
       quit_closure.Run();
     }
   };
 
   class FakeUpdateChecker : public UpdateChecker {
    public:
     static scoped_ptr<UpdateChecker> Create(
-        const scoped_refptr<Configurator>& config) {
+        const scoped_refptr<Configurator>& config,
+        const PersistedData& metadata) {
       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 {
       /*
       Fake the following response:
 
@@ skipping 162 matching lines @@
    public:
     static void Callback(const base::Closure& quit_closure, int error) {
       EXPECT_EQ(0, error);
       quit_closure.Run();
     }
   };
 
   class FakeUpdateChecker : public UpdateChecker {
    public:
     static scoped_ptr<UpdateChecker> Create(
-        const scoped_refptr<Configurator>& config) {
+        const scoped_refptr<Configurator>& config,
+        const PersistedData& metadata) {
       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;
 
@@ skipping 268 matching lines @@
       EXPECT_EQ(0, error);
 
       if (num_call == 2)
         quit_closure.Run();
     }
   };
 
   class FakeUpdateChecker : public UpdateChecker {
    public:
     static scoped_ptr<UpdateChecker> Create(
-        const scoped_refptr<Configurator>& config) {
+        const scoped_refptr<Configurator>& config,
+        const PersistedData& metadata) {
       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(), 0));
@@ skipping 78 matching lines @@
    public:
     static void Callback(const base::Closure& quit_closure, int error) {
       EXPECT_EQ(0, error);
       quit_closure.Run();
     }
   };
 
   class FakeUpdateChecker : public UpdateChecker {
    public:
     static scoped_ptr<UpdateChecker> Create(
-        const scoped_refptr<Configurator>& config) {
+        const scoped_refptr<Configurator>& config,
+        const PersistedData& metadata) {
       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 {
       /*
       Fake the following response:
 
@@ skipping 165 matching lines @@
       if (num_call == 2) {
         EXPECT_EQ(0, error);
         quit_closure.Run();
       }
     }
   };
 
   class FakeUpdateChecker : public UpdateChecker {
    public:
     static scoped_ptr<UpdateChecker> Create(
-        const scoped_refptr<Configurator>& config) {
+        const scoped_refptr<Configurator>& config,
+        const PersistedData& metadata) {
       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(), 0));
@@ skipping 72 matching lines @@
 
   class CompletionCallbackFake {
    public:
     static void Callback(const base::Closure& quit_closure, int error) {
       quit_closure.Run();
     }
   };
   class FakeUpdateChecker : public UpdateChecker {
    public:
     static scoped_ptr<UpdateChecker> Create(
-        const scoped_refptr<Configurator>& config) {
+        const scoped_refptr<Configurator>& config,
+        const PersistedData& metadata) {
       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 {
       return false;
     }
   };
@@ skipping 24 matching lines @@
   update_client->Update(
       empty_id_list, base::Bind(&DataCallbackFake::Callback),
       base::Bind(&CompletionCallbackFake::Callback, runloop.QuitClosure()));
   runloop.Run();
 }
 
 TEST_F(UpdateClientTest, SendUninstallPing) {
   class FakeUpdateChecker : public UpdateChecker {
    public:
     static scoped_ptr<UpdateChecker> Create(
-        const scoped_refptr<Configurator>& config) {
+        const scoped_refptr<Configurator>& config,
+        const PersistedData& metadata) {
       return nullptr;
     }
 
     bool CheckForUpdates(
         const std::vector<CrxUpdateItem*>& items_to_check,
         const std::string& additional_attributes,
         const UpdateCheckCallback& update_check_callback) override {
       return false;
     }
   };
@@ skipping 76 matching lines @@
         EXPECT_EQ(0, error);
       }
 
       quit_closure.Run();
     }
   };
 
   class FakeUpdateChecker : public UpdateChecker {
    public:
     static scoped_ptr<UpdateChecker> Create(
-        const scoped_refptr<Configurator>& config) {
+        const scoped_refptr<Configurator>& config,
+        const PersistedData& metadata) {
       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;
 
@@ skipping 105 matching lines @@
     update_client->Update(
         ids, base::Bind(&DataCallbackFake::Callback),
         base::Bind(&CompletionCallbackFake::Callback, runloop.QuitClosure()));
     runloop.Run();
   }
 
   update_client->RemoveObserver(&observer);
 }
 
 }  // namespace update_client