Replace MessageLoop::current() with ThreadTaskRunnerHandle::Get() in GCM

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"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/test/test_simple_task_runner.h"
+#include "base/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"
 
 namespace gcm {
 
 namespace {
 
@@ skipping 26 matching lines @@
 
   void PumpLoop();
 
   void LoadCallback(scoped_ptr<GCMStore::LoadResult>* result_dst,
                     scoped_ptr<GCMStore::LoadResult> result);
   void LoadWithoutCheckCallback(scoped_ptr<GCMStore::LoadResult>* result_dst,
                                 scoped_ptr<GCMStore::LoadResult> result);
   void UpdateCallback(bool success);
 
  protected:
-  base::MessageLoop message_loop_;
+  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
+  base::ThreadTaskRunnerHandle task_runner_handle_;
   base::ScopedTempDir temp_directory_;
   bool expected_success_;
   uint64 next_persistent_id_;
-  scoped_ptr<base::RunLoop> run_loop_;
 };
 
 GCMStoreImplTest::GCMStoreImplTest()
-    : expected_success_(true),
+    : 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());
-  run_loop_.reset(new base::RunLoop());
 }
 
 GCMStoreImplTest::~GCMStoreImplTest() {}
 
 scoped_ptr<GCMStoreImpl> GCMStoreImplTest::BuildGCMStore() {
   return scoped_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_.path().Append(FILE_PATH_LITERAL("GCM Store")),
-      message_loop_.task_runner(),
+      task_runner_,
       make_scoped_ptr<Encryptor>(new FakeEncryptor)));
 }
 
 void GCMStoreImplTest::LoadGCMStore(
     GCMStoreImpl* gcm_store, scoped_ptr<GCMStore::LoadResult>* result_dst) {
   gcm_store->Load(
       GCMStore::CREATE_IF_MISSING,
       base::Bind(&GCMStoreImplTest::LoadCallback,
                  base::Unretained(this),
                  result_dst));
   PumpLoop();
 }
 
 std::string GCMStoreImplTest::GetNextPersistentId() {
   return base::Uint64ToString(next_persistent_id_++);
 }
 
-void GCMStoreImplTest::PumpLoop() { message_loop_.RunUntilIdle(); }
+void GCMStoreImplTest::PumpLoop() { task_runner_->RunUntilIdle(); }
 
 void GCMStoreImplTest::LoadCallback(
     scoped_ptr<GCMStore::LoadResult>* result_dst,
     scoped_ptr<GCMStore::LoadResult> result) {
   ASSERT_TRUE(result->success);
   LoadWithoutCheckCallback(result_dst, result.Pass());
 }
 
 void GCMStoreImplTest::LoadWithoutCheckCallback(
     scoped_ptr<GCMStore::LoadResult>* result_dst,
     scoped_ptr<GCMStore::LoadResult> result) {
   *result_dst = result.Pass();
-  run_loop_->Quit();
-  run_loop_.reset(new base::RunLoop());
 }
 
 void GCMStoreImplTest::UpdateCallback(bool success) {
   ASSERT_EQ(expected_success_, success);
 }
 
 // Verify creating a new database and loading it.
 TEST_F(GCMStoreImplTest, LoadNew) {
   scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore());
   scoped_ptr<GCMStore::LoadResult> load_result;
@@ skipping 600 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