content: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

content/browser/database_quota_client_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 <map>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/location.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/thread_task_runner_handle.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "storage/browser/database/database_quota_client.h"
 #include "storage/browser/database/database_tracker.h"
 #include "storage/browser/database/database_util.h"
 #include "storage/common/database/database_identifier.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using storage::DatabaseQuotaClient;
 using storage::DatabaseTracker;
@@ skipping 43 matching lines @@
          ++iter) {
       origins_info->push_back(OriginInfo(iter->second));
     }
     return true;
   }
 
   int DeleteDataForOrigin(const std::string& origin_identifier,
                           const net::CompletionCallback& callback) override {
     ++delete_called_count_;
     if (async_delete()) {
-      base::MessageLoopProxy::current()->PostTask(
-          FROM_HERE,
-          base::Bind(&MockDatabaseTracker::AsyncDeleteDataForOrigin, this,
-                     callback));
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE, base::Bind(&MockDatabaseTracker::AsyncDeleteDataForOrigin,
+                                this, callback));
       return net::ERR_IO_PENDING;
     }
     return net::OK;
   }
 
   void AsyncDeleteDataForOrigin(const net::CompletionCallback& callback) {
     callback.Run(net::OK);
   }
 
   void AddMockDatabase(const GURL& origin,  const char* name, int size) {
@@ skipping 111 matching lines @@
   base::MessageLoop message_loop_;
   int64 usage_;
   std::set<GURL> origins_;
   storage::QuotaStatusCode delete_status_;
   scoped_refptr<MockDatabaseTracker> mock_tracker_;
   base::WeakPtrFactory<DatabaseQuotaClientTest> weak_factory_;
 };
 
 
 TEST_F(DatabaseQuotaClientTest, GetOriginUsage) {
-  DatabaseQuotaClient client(base::MessageLoopProxy::current().get(),
+  DatabaseQuotaClient client(base::ThreadTaskRunnerHandle::Get().get(),
                              mock_tracker());
 
   EXPECT_EQ(0, GetOriginUsage(&client, kOriginA, kTemp));
   EXPECT_EQ(0, GetOriginUsage(&client, kOriginA, kPerm));
 
   mock_tracker()->AddMockDatabase(kOriginA, "fooDB", 1000);
   EXPECT_EQ(1000, GetOriginUsage(&client, kOriginA, kTemp));
   EXPECT_EQ(0, GetOriginUsage(&client, kOriginA, kPerm));
 
   EXPECT_EQ(0, GetOriginUsage(&client, kOriginB, kPerm));
   EXPECT_EQ(0, GetOriginUsage(&client, kOriginB, kTemp));
 }
 
 TEST_F(DatabaseQuotaClientTest, GetOriginsForHost) {
-  DatabaseQuotaClient client(base::MessageLoopProxy::current().get(),
+  DatabaseQuotaClient client(base::ThreadTaskRunnerHandle::Get().get(),
                              mock_tracker());
 
   EXPECT_EQ(kOriginA.host(), kOriginB.host());
   EXPECT_NE(kOriginA.host(), kOriginOther.host());
 
   std::set<GURL> origins = GetOriginsForHost(&client, kTemp, kOriginA.host());
   EXPECT_TRUE(origins.empty());
 
   mock_tracker()->AddMockDatabase(kOriginA, "fooDB", 1000);
   origins = GetOriginsForHost(&client, kTemp, kOriginA.host());
   EXPECT_EQ(origins.size(), 1ul);
   EXPECT_TRUE(origins.find(kOriginA) != origins.end());
 
   mock_tracker()->AddMockDatabase(kOriginB, "barDB", 1000);
   origins = GetOriginsForHost(&client, kTemp, kOriginA.host());
   EXPECT_EQ(origins.size(), 2ul);
   EXPECT_TRUE(origins.find(kOriginA) != origins.end());
   EXPECT_TRUE(origins.find(kOriginB) != origins.end());
 
   EXPECT_TRUE(GetOriginsForHost(&client, kPerm, kOriginA.host()).empty());
   EXPECT_TRUE(GetOriginsForHost(&client, kTemp, kOriginOther.host()).empty());
 }
 
 TEST_F(DatabaseQuotaClientTest, GetOriginsForType) {
-  DatabaseQuotaClient client(base::MessageLoopProxy::current().get(),
+  DatabaseQuotaClient client(base::ThreadTaskRunnerHandle::Get().get(),
                              mock_tracker());
 
   EXPECT_TRUE(GetOriginsForType(&client, kTemp).empty());
   EXPECT_TRUE(GetOriginsForType(&client, kPerm).empty());
 
   mock_tracker()->AddMockDatabase(kOriginA, "fooDB", 1000);
   std::set<GURL> origins = GetOriginsForType(&client, kTemp);
   EXPECT_EQ(origins.size(), 1ul);
   EXPECT_TRUE(origins.find(kOriginA) != origins.end());
 
   EXPECT_TRUE(GetOriginsForType(&client, kPerm).empty());
 }
 
 TEST_F(DatabaseQuotaClientTest, DeleteOriginData) {
-  DatabaseQuotaClient client(base::MessageLoopProxy::current().get(),
+  DatabaseQuotaClient client(base::ThreadTaskRunnerHandle::Get().get(),
                              mock_tracker());
 
   // Perm deletions are short circuited in the Client and
   // should not reach the DatabaseTracker.
   EXPECT_TRUE(DeleteOriginData(&client, kPerm, kOriginA));
   EXPECT_EQ(0, mock_tracker()->delete_called_count());
 
   mock_tracker()->set_async_delete(false);
   EXPECT_TRUE(DeleteOriginData(&client, kTemp, kOriginA));
   EXPECT_EQ(1, mock_tracker()->delete_called_count());
 
   mock_tracker()->set_async_delete(true);
   EXPECT_TRUE(DeleteOriginData(&client, kTemp, kOriginA));
   EXPECT_EQ(2, mock_tracker()->delete_called_count());
 }
 
 }  // namespace content