Remove use of deprecated MessageLoop methods in extensions.

extensions/browser/process_manager.cc

 // Copyright 2013 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 "extensions/browser/process_manager.h"
 
 #include <vector>
 
 #include "base/bind.h"
+#include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
@@ skipping 523 matching lines @@
   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
   if (host &&
       sequence_id == background_page_data_[extension_id].close_sequence_id) {
     host->render_process_host()->Send(new ExtensionMsg_Suspend(extension_id));
   }
 }
 
 void ProcessManager::OnSuspendAck(const std::string& extension_id) {
   background_page_data_[extension_id].is_closing = true;
   uint64_t sequence_id = background_page_data_[extension_id].close_sequence_id;
-  base::MessageLoop::current()->PostDelayedTask(
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ProcessManager::CloseLazyBackgroundPageNow,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 extension_id,
-                 sequence_id),
+                 weak_ptr_factory_.GetWeakPtr(), extension_id, sequence_id),
       base::TimeDelta::FromMilliseconds(g_event_page_suspending_time_msec));
 }
 
 void ProcessManager::OnNetworkRequestStarted(
     content::RenderFrameHost* render_frame_host,
     uint64_t request_id) {
   ExtensionHost* host = GetBackgroundHostForExtension(
       GetExtensionID(render_frame_host));
   if (!host || !IsFrameInExtensionHost(host, render_frame_host))
     return;
@@ skipping 206 matching lines @@
   DCHECK(count > 0 ||
          !extension_registry_->enabled_extensions().Contains(extension_id));
 
   // If we reach a zero keepalive count when the lazy background page is about
   // to be closed, incrementing close_sequence_id will cancel the close
   // sequence and cause the background page to linger. So check is_closing
   // before initiating another close sequence.
   if (--count == 0 && !background_page_data_[extension_id].is_closing) {
     background_page_data_[extension_id].close_sequence_id =
         ++last_background_close_sequence_id_;
-    base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&ProcessManager::OnLazyBackgroundPageIdle,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   extension_id,
-                   last_background_close_sequence_id_),
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE, base::Bind(&ProcessManager::OnLazyBackgroundPageIdle,
+                              weak_ptr_factory_.GetWeakPtr(), extension_id,
+                              last_background_close_sequence_id_),
         base::TimeDelta::FromMilliseconds(g_event_page_idle_time_msec));
   }
 }
 
 // DecrementLazyKeepaliveCount is called when no calls to KeepaliveImpulse
 // have been made for at least g_event_page_idle_time_msec. In the best case an
 // impulse was made just before being cleared, and the decrement will occur
 // g_event_page_idle_time_msec later, causing a 2 * g_event_page_idle_time_msec
 // total time for extension to be shut down based on impulses. Worst case is
 // an impulse just after a clear, adding one check cycle and resulting in 3x
@@ skipping 11 matching lines @@
       }
     }
 
     i->second.previous_keepalive_impulse = i->second.keepalive_impulse;
     i->second.keepalive_impulse = false;
   }
 
   // OnKeepaliveImpulseCheck() is always called in constructor, but in unit
   // tests there will be no message loop. In that event don't schedule tasks.
   if (base::MessageLoop::current()) {
-    base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&ProcessManager::OnKeepaliveImpulseCheck,
-                   weak_ptr_factory_.GetWeakPtr()),
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE, base::Bind(&ProcessManager::OnKeepaliveImpulseCheck,
+                              weak_ptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(g_event_page_idle_time_msec));
   }
 }
 
 void ProcessManager::OnLazyBackgroundPageIdle(const std::string& extension_id,
                                               uint64_t sequence_id) {
   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
   if (host && !background_page_data_[extension_id].is_closing &&
       sequence_id == background_page_data_[extension_id].close_sequence_id) {
     // Tell the renderer we are about to close. This is a simple ping that the
@@ skipping 149 matching lines @@
   if (extension && !IncognitoInfo::IsSplitMode(extension)) {
     BrowserContext* original_context =
         ExtensionsBrowserClient::Get()->GetOriginalContext(browser_context());
     return ProcessManager::Get(original_context)->GetSiteInstanceForURL(url);
   }
 
   return ProcessManager::GetSiteInstanceForURL(url);
 }
 
 }  // namespace extensions