GCM Store: Fix invalid argument errors

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 <stdint.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
+#include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "google_apis/gcm/base/fake_encryptor.h"
 #include "google_apis/gcm/base/mcs_message.h"
 #include "google_apis/gcm/base/mcs_util.h"
 #include "google_apis/gcm/protocol/mcs.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 35 matching lines @@
                     std::unique_ptr<GCMStore::LoadResult> result);
   void LoadWithoutCheckCallback(
       std::unique_ptr<GCMStore::LoadResult>* result_dst,
       std::unique_ptr<GCMStore::LoadResult> result);
   void UpdateCallback(bool success);
 
  protected:
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle task_runner_handle_;
   base::ScopedTempDir temp_directory_;
+  base::FilePath store_path_;
   bool expected_success_;
   uint64_t next_persistent_id_;
 };
 
 GCMStoreImplTest::GCMStoreImplTest()
     : task_runner_(new base::TestSimpleTaskRunner()),
       task_runner_handle_(task_runner_),
       expected_success_(true),
       next_persistent_id_(base::Time::Now().ToInternalValue()) {
   EXPECT_TRUE(temp_directory_.CreateUniqueTempDir());
 }
 
 GCMStoreImplTest::~GCMStoreImplTest() {}
 
 std::unique_ptr<GCMStoreImpl> GCMStoreImplTest::BuildGCMStore() {
-  return std::unique_ptr<GCMStoreImpl>(new GCMStoreImpl(
-      // Pass an non-existent directory as store path to match the exact
-      // behavior in the production code. Currently GCMStoreImpl checks if
-      // the directory exist or not to determine the store existence.
-      temp_directory_.GetPath().Append(FILE_PATH_LITERAL("GCM Store")),
-      task_runner_, base::WrapUnique<Encryptor>(new FakeEncryptor)));
+  // Pass an non-existent directory as store path to match the exact behavior in
+  // the production code. Currently GCMStoreImpl checks if the directory exists
+  // and contains a CURRENT file to determine the store existence.
+  store_path_ =
+      temp_directory_.GetPath().Append(FILE_PATH_LITERAL("GCM Store"));
+  return std::unique_ptr<GCMStoreImpl>(
+      new GCMStoreImpl(store_path_, task_runner_,
+                       base::WrapUnique<Encryptor>(new FakeEncryptor)));
 }
 
 void GCMStoreImplTest::LoadGCMStore(
     GCMStoreImpl* gcm_store,
     std::unique_ptr<GCMStore::LoadResult>* result_dst) {
   gcm_store->Load(
       GCMStore::CREATE_IF_MISSING,
       base::Bind(&GCMStoreImplTest::LoadCallback,
                  base::Unretained(this),
                  result_dst));
@@ skipping 30 matching lines @@
   LoadGCMStore(gcm_store.get(), &load_result);
 
   EXPECT_EQ(0U, load_result->device_android_id);
   EXPECT_EQ(0U, load_result->device_security_token);
   EXPECT_TRUE(load_result->incoming_messages.empty());
   EXPECT_TRUE(load_result->outgoing_messages.empty());
   EXPECT_TRUE(load_result->gservices_settings.empty());
   EXPECT_EQ(base::Time::FromInternalValue(0LL), load_result->last_checkin_time);
 }
 
-// Verify new database is not created when DO_NOT_CREATE_NEW_STORE is passed.
+// Verify new database is not created when DO_NOT_CREATE is passed.
 TEST_F(GCMStoreImplTest, LoadWithoutCreatingNewStore) {
   std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
   std::unique_ptr<GCMStore::LoadResult> load_result;
-  gcm_store->Load(
-      GCMStore::DO_NOT_CREATE,
-      base::Bind(&GCMStoreImplTest::LoadWithoutCheckCallback,
-                 base::Unretained(this),
-                 &load_result));
+  gcm_store->Load(GCMStore::DO_NOT_CREATE,
+                  base::Bind(&GCMStoreImplTest::LoadWithoutCheckCallback,
+                             base::Unretained(this), &load_result));
   PumpLoop();
 
   EXPECT_FALSE(load_result->success);
+  EXPECT_TRUE(load_result->store_does_not_exist);
+}
+
+// Verifies that loads with DO_NOT_CREATE set store_does_not_exist to true when
+// an empty directory was left behind after destroying the database.
+TEST_F(GCMStoreImplTest, LoadWithEmptyDirectory) {
+  std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
+
+  // Create an empty directory at the store path, to simulate an empty directory
+  // being left behind after destroying a previous store.
+  ASSERT_TRUE(base::CreateDirectory(store_path_));
+
+  std::unique_ptr<GCMStore::LoadResult> load_result;
+  gcm_store->Load(GCMStore::DO_NOT_CREATE,
+                  base::Bind(&GCMStoreImplTest::LoadWithoutCheckCallback,
+                             base::Unretained(this), &load_result));
+  PumpLoop();
+
+  EXPECT_FALSE(load_result->success);
   EXPECT_TRUE(load_result->store_does_not_exist);
 }
 
 TEST_F(GCMStoreImplTest, DeviceCredentials) {
   std::unique_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
   std::unique_ptr<GCMStore::LoadResult> load_result;
   LoadGCMStore(gcm_store.get(), &load_result);
 
   gcm_store->SetDeviceCredentials(
       kDeviceId,
@@ skipping 568 matching lines @@
 
   ASSERT_EQ(1u, load_result->instance_id_data.size());
   ASSERT_TRUE(load_result->instance_id_data.find(kAppName2) !=
               load_result->instance_id_data.end());
   EXPECT_EQ(instance_id_data2, load_result->instance_id_data[kAppName2]);
 }
 
 }  // namespace
 
 }  // namespace gcm