[chrome/browser/extensions] Replace MessageLoopProxy usage with ThreadTaskRunnerHandle

chrome/browser/extensions/blacklist.cc

 // Copyright 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 "chrome/browser/extensions/blacklist.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "base/prefs/pref_service.h"
+#include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
+#include "base/thread_task_runner_handle.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/blacklist_factory.h"
 #include "chrome/browser/extensions/blacklist_state_fetcher.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "extensions/browser/extension_prefs.h"
 
@@ skipping 40 matching lines @@
     : public SafeBrowsingDatabaseManager::Client,
       public base::RefCountedThreadSafe<SafeBrowsingClientImpl> {
  public:
   typedef base::Callback<void(const std::set<std::string>&)> OnResultCallback;
 
   // Constructs a client to query the database manager for |extension_ids| and
   // run |callback| with the IDs of those which have been blacklisted.
   SafeBrowsingClientImpl(
       const std::set<std::string>& extension_ids,
       const OnResultCallback& callback)
-      : callback_message_loop_(base::MessageLoopProxy::current()),
+      : callback_task_runner_(base::ThreadTaskRunnerHandle::Get()),
         callback_(callback) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&SafeBrowsingClientImpl::StartCheck, this,
                    g_database_manager.Get().get(),
                    extension_ids));
   }
 
  private:
   friend class base::RefCountedThreadSafe<SafeBrowsingClientImpl>;
   ~SafeBrowsingClientImpl() override {}
 
   // Pass |database_manager| as a parameter to avoid touching
   // SafeBrowsingService on the IO thread.
   void StartCheck(scoped_refptr<SafeBrowsingDatabaseManager> database_manager,
                   const std::set<std::string>& extension_ids) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     if (database_manager->CheckExtensionIDs(extension_ids, this)) {
       // Definitely not blacklisted. Callback immediately.
-      callback_message_loop_->PostTask(
+      callback_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(callback_, std::set<std::string>()));
       return;
     }
     // Something might be blacklisted, response will come in
     // OnCheckExtensionsResult.
     AddRef();  // Balanced in OnCheckExtensionsResult
   }
 
   void OnCheckExtensionsResult(const std::set<std::string>& hits) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
-    callback_message_loop_->PostTask(FROM_HERE, base::Bind(callback_, hits));
+    callback_task_runner_->PostTask(FROM_HERE, base::Bind(callback_, hits));
     Release();  // Balanced in StartCheck.
   }
 
-  scoped_refptr<base::MessageLoopProxy> callback_message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> callback_task_runner_;
   OnResultCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingClientImpl);
 };
 
 void CheckOneExtensionState(
     const Blacklist::IsBlacklistedCallback& callback,
     const Blacklist::BlacklistStateMap& state_map) {
   callback.Run(state_map.empty() ? NOT_BLACKLISTED : state_map.begin()->second);
 }
@@ skipping 61 matching lines @@
 // static
 Blacklist* Blacklist::Get(content::BrowserContext* context) {
   return BlacklistFactory::GetForBrowserContext(context);
 }
 
 void Blacklist::GetBlacklistedIDs(const std::set<std::string>& ids,
                                   const GetBlacklistedIDsCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (ids.empty() || !g_database_manager.Get().get().get()) {
-    base::MessageLoopProxy::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, BlacklistStateMap()));
     return;
   }
 
   // Constructing the SafeBrowsingClientImpl begins the process of asking
   // safebrowsing for the blacklisted extensions. The set of blacklisted
   // extensions returned by SafeBrowsing will then be passed to
   // GetBlacklistStateIDs to get the particular BlacklistState for each id.
   new SafeBrowsingClientImpl(
       ids, base::Bind(&Blacklist::GetBlacklistStateForIDs, AsWeakPtr(),
@@ skipping 142 matching lines @@
 }
 
 void Blacklist::Observe(int type,
                         const content::NotificationSource& source,
                         const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE, type);
   FOR_EACH_OBSERVER(Observer, observers_, OnBlacklistUpdated());
 }
 
 }  // namespace extensions