content: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

content/browser/appcache/appcache_storage_impl.cc

 // Copyright (c) 2012 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 "content/browser/appcache/appcache_storage_impl.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
+#include "base/location.h"
 #include "base/logging.h"
-#include "base/message_loop/message_loop.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
+#include "base/thread_task_runner_handle.h"
 #include "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_database.h"
 #include "content/browser/appcache/appcache_entry.h"
 #include "content/browser/appcache/appcache_group.h"
 #include "content/browser/appcache/appcache_histograms.h"
 #include "content/browser/appcache/appcache_quota_client.h"
 #include "content/browser/appcache/appcache_response.h"
 #include "content/browser/appcache/appcache_service_impl.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_errors.h"
@@ skipping 98 matching lines @@
 }
 
 }  // namespace
 
 // DatabaseTask -----------------------------------------
 
 class AppCacheStorageImpl::DatabaseTask
     : public base::RefCountedThreadSafe<DatabaseTask> {
  public:
   explicit DatabaseTask(AppCacheStorageImpl* storage)
-      : storage_(storage), database_(storage->database_),
-        io_thread_(base::MessageLoopProxy::current()) {
+      : storage_(storage),
+        database_(storage->database_),
+        io_thread_(base::ThreadTaskRunnerHandle::Get()) {
     DCHECK(io_thread_.get());
   }
 
   void AddDelegate(DelegateReference* delegate_reference) {
     delegates_.push_back(make_scoped_refptr(delegate_reference));
   }
 
   // Schedules a task to be Run() on the DB thread. Tasks
   // are run in the order in which they are scheduled.
   void Schedule();
@@ skipping 20 matching lines @@
 
   AppCacheStorageImpl* storage_;
   AppCacheDatabase* database_;
   DelegateReferenceVector delegates_;
 
  private:
   void CallRun(base::TimeTicks schedule_time);
   void CallRunCompleted(base::TimeTicks schedule_time);
   void OnFatalError();
 
-  scoped_refptr<base::MessageLoopProxy> io_thread_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_thread_;
 };
 
 void AppCacheStorageImpl::DatabaseTask::Schedule() {
   DCHECK(storage_);
   DCHECK(io_thread_->BelongsToCurrentThread());
   if (!storage_->database_)
     return;
 
   if (storage_->db_thread_->PostTask(
           FROM_HERE,
@@ skipping 115 matching lines @@
 
 void AppCacheStorageImpl::InitTask::RunCompleted() {
   storage_->last_group_id_ = last_group_id_;
   storage_->last_cache_id_ = last_cache_id_;
   storage_->last_response_id_ = last_response_id_;
   storage_->last_deletable_response_rowid_ = last_deletable_response_rowid_;
 
   if (!storage_->is_disabled()) {
     storage_->usage_map_.swap(usage_map_);
     const base::TimeDelta kDelay = base::TimeDelta::FromMinutes(5);
-    base::MessageLoop::current()->PostDelayedTask(
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&AppCacheStorageImpl::DelayedStartDeletingUnusedResponses,
                    storage_->weak_factory_.GetWeakPtr()),
         kDelay);
   }
 
   if (storage_->service()->quota_client())
     storage_->service()->quota_client()->NotifyAppCacheReady();
 }
 
@@ skipping 1403 matching lines @@
   deletable_response_ids_.insert(
       deletable_response_ids_.end(),
       response_ids.begin(), response_ids.end());
   if (!is_response_deletion_scheduled_)
     ScheduleDeleteOneResponse();
 }
 
 void AppCacheStorageImpl::ScheduleDeleteOneResponse() {
   DCHECK(!is_response_deletion_scheduled_);
   const base::TimeDelta kBriefDelay = base::TimeDelta::FromMilliseconds(10);
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&AppCacheStorageImpl::DeleteOneResponse,
-                 weak_factory_.GetWeakPtr()),
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, base::Bind(&AppCacheStorageImpl::DeleteOneResponse,
+                            weak_factory_.GetWeakPtr()),
       kBriefDelay);
   is_response_deletion_scheduled_ = true;
 }
 
 void AppCacheStorageImpl::DeleteOneResponse() {
   DCHECK(is_response_deletion_scheduled_);
   DCHECK(!deletable_response_ids_.empty());
 
   if (!disk_cache()) {
     DCHECK(is_disabled_);
@@ skipping 62 matching lines @@
   PendingForeignMarkings::iterator iter = pending_foreign_markings_.begin();
   while (iter != pending_foreign_markings_.end()) {
     if (iter->second == cache_id)
       urls->push_back(iter->first);
     ++iter;
   }
 }
 
 void AppCacheStorageImpl::ScheduleSimpleTask(const base::Closure& task) {
   pending_simple_tasks_.push_back(task);
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE,
-      base::Bind(&AppCacheStorageImpl::RunOnePendingSimpleTask,
-                 weak_factory_.GetWeakPtr()));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&AppCacheStorageImpl::RunOnePendingSimpleTask,
+                            weak_factory_.GetWeakPtr()));
 }
 
 void AppCacheStorageImpl::RunOnePendingSimpleTask() {
   DCHECK(!pending_simple_tasks_.empty());
   base::Closure task = pending_simple_tasks_.front();
   pending_simple_tasks_.pop_front();
   task.Run();
 }
 
 AppCacheDiskCache* AppCacheStorageImpl::disk_cache() {
@@ skipping 80 matching lines @@
 
 void AppCacheStorageImpl::OnLazyCommitTimer() {
   lazy_commit_timer_.Stop();
   if (is_disabled())
     return;
   scoped_refptr<DatabaseTask> task(new CommitLastAccessTimesTask(this));
   task->Schedule();
 }
 
 }  // namespace content