components: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

components/leveldb_proto/proto_database_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 "components/leveldb_proto/proto_database_impl.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/location.h"
 #include "base/run_loop.h"
 #include "base/threading/thread.h"
 #include "components/leveldb_proto/leveldb_database.h"
 #include "components/leveldb_proto/testing/proto/test.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/src/include/leveldb/options.h"
 
 using base::MessageLoop;
 using base::ScopedTempDir;
@@ skipping 57 matching lines @@
     std::string serialized_actual = actual[i].SerializeAsString();
     EXPECT_EQ(serialized_expected, serialized_actual);
     expected.erase(expected_it);
   }
 }
 
 class ProtoDatabaseImplTest : public testing::Test {
  public:
   void SetUp() override {
     main_loop_.reset(new MessageLoop());
-    db_.reset(
-        new ProtoDatabaseImpl<TestProto>(main_loop_->message_loop_proxy()));
+    db_.reset(new ProtoDatabaseImpl<TestProto>(main_loop_->task_runner()));
   }
 
   void TearDown() override {
     db_.reset();
     base::RunLoop().RunUntilIdle();
     main_loop_.reset();
   }
 
   scoped_ptr<ProtoDatabaseImpl<TestProto> > db_;
   scoped_ptr<MessageLoop> main_loop_;
@@ skipping 224 matching lines @@
 // threading violations.
 TEST(ProtoDatabaseImplThreadingTest, TestDBDestruction) {
   base::MessageLoop main_loop;
 
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   base::Thread db_thread("dbthread");
   ASSERT_TRUE(db_thread.Start());
 
-  scoped_ptr<ProtoDatabaseImpl<TestProto> > db(
-      new ProtoDatabaseImpl<TestProto>(db_thread.message_loop_proxy()));
+  scoped_ptr<ProtoDatabaseImpl<TestProto>> db(
+      new ProtoDatabaseImpl<TestProto>(db_thread.task_runner()));
 
   MockDatabaseCaller caller;
   EXPECT_CALL(caller, InitCallback(_));
   db->Init(temp_dir.path(), base::Bind(&MockDatabaseCaller::InitCallback,
                                        base::Unretained(&caller)));
 
   db.reset();
 
   base::RunLoop run_loop;
-  db_thread.message_loop_proxy()->PostTaskAndReply(
+  db_thread.task_runner()->PostTaskAndReply(
       FROM_HERE, base::Bind(base::DoNothing), run_loop.QuitClosure());
   run_loop.Run();
 }
 
 // Test that the LevelDB properly saves entries and that load returns the saved
 // entries. If |close_after_save| is true, the database will be closed after
 // saving and then re-opened to ensure that the data is properly persisted.
 void TestLevelDBSaveAndLoad(bool close_after_save) {
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
@@ skipping 49 matching lines @@
   KeyValueVector save_entries;
   std::vector<std::string> load_entries;
   KeyVector remove_keys;
 
   EXPECT_FALSE(db->InitWithOptions(temp_dir.path(), options));
   EXPECT_FALSE(db->Load(&load_entries));
   EXPECT_FALSE(db->Save(save_entries, remove_keys));
 }
 
 }  // namespace leveldb_proto