[GCM] Fixing the initialization of last checkin/fetch time if they are

google_apis/gcm/engine/gcm_store_impl_unittest.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 "google_apis/gcm/engine/gcm_store_impl.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 27 matching lines @@
 const char kCategoryName[] = "my_category";
 
 const uint64 kDeviceId = 22;
 const uint64 kDeviceToken = 55;
 
 class GCMStoreImplTest : public testing::Test {
  public:
   GCMStoreImplTest();
   ~GCMStoreImplTest() override;
 
-  scoped_ptr<GCMStore> BuildGCMStore();
+  scoped_ptr<GCMStoreImpl> BuildGCMStore();
 
   std::string GetNextPersistentId();
 
   void PumpLoop();
 
   void LoadCallback(scoped_ptr<GCMStore::LoadResult>* result_dst,
                     scoped_ptr<GCMStore::LoadResult> result);
   void UpdateCallback(bool success);
 
  protected:
   base::MessageLoop message_loop_;
   base::ScopedTempDir temp_directory_;
   bool expected_success_;
   uint64 next_persistent_id_;
   scoped_ptr<base::RunLoop> run_loop_;
 };
 
 GCMStoreImplTest::GCMStoreImplTest()
     : expected_success_(true),
       next_persistent_id_(base::Time::Now().ToInternalValue()) {
   EXPECT_TRUE(temp_directory_.CreateUniqueTempDir());
   run_loop_.reset(new base::RunLoop());
 }
 
 GCMStoreImplTest::~GCMStoreImplTest() {}
 
-scoped_ptr<GCMStore> GCMStoreImplTest::BuildGCMStore() {
-  return scoped_ptr<GCMStore>(new GCMStoreImpl(
+scoped_ptr<GCMStoreImpl> GCMStoreImplTest::BuildGCMStore() {
+  return scoped_ptr<GCMStoreImpl>(new GCMStoreImpl(
       temp_directory_.path(),
       message_loop_.message_loop_proxy(),
       make_scoped_ptr<Encryptor>(new FakeEncryptor)));
 }
 
 std::string GCMStoreImplTest::GetNextPersistentId() {
   return base::Uint64ToString(next_persistent_id_++);
 }
 
 void GCMStoreImplTest::PumpLoop() { message_loop_.RunUntilIdle(); }
@@ skipping 43 matching lines @@
   gcm_store = BuildGCMStore().Pass();
   gcm_store->Load(base::Bind(
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
 
   ASSERT_EQ(kDeviceId, load_result->device_android_id);
   ASSERT_EQ(kDeviceToken, load_result->device_security_token);
 }
 
 TEST_F(GCMStoreImplTest, LastCheckinInfo) {
-  scoped_ptr<GCMStore> gcm_store(BuildGCMStore());
+  scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
   scoped_ptr<GCMStore::LoadResult> load_result;
   gcm_store->Load(base::Bind(
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
 
   base::Time last_checkin_time = base::Time::Now();
   std::set<std::string> accounts;
   accounts.insert("test_user1@gmail.com");
   accounts.insert("test_user2@gmail.com");
 
   gcm_store->SetLastCheckinInfo(
       last_checkin_time,
       accounts,
       base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this)));
   PumpLoop();
 
   gcm_store = BuildGCMStore().Pass();
   gcm_store->Load(base::Bind(
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
   ASSERT_EQ(last_checkin_time, load_result->last_checkin_time);
   ASSERT_EQ(accounts, load_result->last_checkin_accounts);
+
+  // Negative cases, where the value read is gibberish.
+  gcm_store->SetValueForTesting(
+      "last_checkin_time",
+      "gibberish",
+      base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this)));
+  PumpLoop();
+
+  gcm_store = BuildGCMStore().Pass();
+  gcm_store->Load(base::Bind(
+      &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
+  PumpLoop();
+  EXPECT_EQ(base::Time(), load_result->last_checkin_time);
 }
 
 TEST_F(GCMStoreImplTest, GServicesSettings_ProtocolV2) {
   scoped_ptr<GCMStore> gcm_store(BuildGCMStore());
   scoped_ptr<GCMStore::LoadResult> load_result;
   gcm_store->Load(base::Bind(
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
 
   std::map<std::string, std::string> settings;
@@ skipping 464 matching lines @@
   gcm_store->Close();
   PumpLoop();
 
   gcm_store->Load(base::Bind(&GCMStoreImplTest::LoadCallback,
                              base::Unretained(this),
                              &load_result));
   PumpLoop();
 }
 
 TEST_F(GCMStoreImplTest, LastTokenFetchTime) {
-  scoped_ptr<GCMStore> gcm_store(BuildGCMStore());
+  scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
   scoped_ptr<GCMStore::LoadResult> load_result;
   gcm_store->Load(base::Bind(
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
   EXPECT_EQ(base::Time(), load_result->last_token_fetch_time);
 
   base::Time last_token_fetch_time = base::Time::Now();
   gcm_store->SetLastTokenFetchTime(
       last_token_fetch_time,
       base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this)));
   PumpLoop();
 
   gcm_store = BuildGCMStore().Pass();
   gcm_store->Load(base::Bind(
       &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
   PumpLoop();
   EXPECT_EQ(last_token_fetch_time, load_result->last_token_fetch_time);
+
+  // Negative cases, where the value read is gibberish.
+  gcm_store->SetValueForTesting(
+      "last_token_fetch_time",
+      "gibberish",
+      base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this)));
+  PumpLoop();
+
+  gcm_store = BuildGCMStore().Pass();
+  gcm_store->Load(base::Bind(
+      &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result));
+  PumpLoop();
+  EXPECT_EQ(base::Time(), load_result->last_token_fetch_time);
 }
 
 }  // namespace
 
 }  // namespace gcm