chrome/browser: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

chrome/browser/speech/extension_api/tts_extension_apitest.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 <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/location.h"
 #include "base/memory/weak_ptr.h"
-#include "base/message_loop/message_loop.h"
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "chrome/browser/extensions/component_loader.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/speech/extension_api/tts_extension_api.h"
 #include "chrome/browser/speech/tts_controller.h"
 #include "chrome/browser/speech/tts_platform.h"
 #include "chrome/common/chrome_switches.h"
 #include "extensions/browser/extension_system.h"
 #include "net/base/network_change_notifier.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 60 matching lines @@
     voices->push_back(voice);
   }
 
   void set_should_fake_get_voices(bool val) { should_fake_get_voices_ = val; }
 
   void SetErrorToEpicFail() {
     set_error("epic fail");
   }
 
   void SendEndEventOnSavedUtteranceId() {
-    base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE, base::Bind(
-            &MockTtsPlatformImpl::SendEvent,
-            ptr_factory_.GetWeakPtr(),
-            false, g_saved_utterance_id, TTS_EVENT_END, 0, std::string()),
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&MockTtsPlatformImpl::SendEvent, ptr_factory_.GetWeakPtr(),
+                   false, g_saved_utterance_id, TTS_EVENT_END, 0,
+                   std::string()),
         base::TimeDelta());
   }
 
   void SendEndEvent(int utterance_id,
                     const std::string& utterance,
                     const std::string& lang,
                     const VoiceData& voice,
                     const UtteranceContinuousParameters& params) {
-    base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE, base::Bind(
-            &MockTtsPlatformImpl::SendEvent,
-            ptr_factory_.GetWeakPtr(),
-            false, utterance_id, TTS_EVENT_END, utterance.size(),
-            std::string()),
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE, base::Bind(&MockTtsPlatformImpl::SendEvent,
+                              ptr_factory_.GetWeakPtr(), false, utterance_id,
+                              TTS_EVENT_END, utterance.size(), std::string()),
         base::TimeDelta());
   }
 
   void SendEndEventWhenQueueNotEmpty(
       int utterance_id,
       const std::string& utterance,
       const std::string& lang,
       const VoiceData& voice,
       const UtteranceContinuousParameters& params) {
-    base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE, base::Bind(
-            &MockTtsPlatformImpl::SendEvent,
-            ptr_factory_.GetWeakPtr(),
-            true, utterance_id, TTS_EVENT_END, utterance.size(), std::string()),
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE, base::Bind(&MockTtsPlatformImpl::SendEvent,
+                              ptr_factory_.GetWeakPtr(), true, utterance_id,
+                              TTS_EVENT_END, utterance.size(), std::string()),
         base::TimeDelta());
   }
 
   void SendWordEvents(int utterance_id,
                       const std::string& utterance,
                       const std::string& lang,
                       const VoiceData& voice,
                       const UtteranceContinuousParameters& params) {
     for (int i = 0; i < static_cast<int>(utterance.size()); i++) {
       if (i == 0 || utterance[i - 1] == ' ') {
-        base::MessageLoop::current()->PostDelayedTask(
-            FROM_HERE, base::Bind(
-                &MockTtsPlatformImpl::SendEvent,
-                ptr_factory_.GetWeakPtr(),
-                false, utterance_id, TTS_EVENT_WORD, i,
-                std::string()),
+        base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+            FROM_HERE,
+            base::Bind(&MockTtsPlatformImpl::SendEvent,
+                       ptr_factory_.GetWeakPtr(), false, utterance_id,
+                       TTS_EVENT_WORD, i, std::string()),
             base::TimeDelta());
       }
     }
   }
 
   void SendEvent(bool wait_for_non_empty_queue,
                  int utterance_id,
                  TtsEventType event_type,
                  int char_index,
                  const std::string& message) {
     TtsController* controller = TtsController::GetInstance();
     if (wait_for_non_empty_queue && controller->QueueSize() == 0) {
-      base::MessageLoop::current()->PostDelayedTask(
-          FROM_HERE, base::Bind(
-              &MockTtsPlatformImpl::SendEvent,
-              ptr_factory_.GetWeakPtr(),
-              true, utterance_id, event_type, char_index, message),
+      base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+          FROM_HERE,
+          base::Bind(&MockTtsPlatformImpl::SendEvent, ptr_factory_.GetWeakPtr(),
+                     true, utterance_id, event_type, char_index, message),
           base::TimeDelta::FromMilliseconds(100));
       return;
     }
 
     controller->OnTtsEvent(utterance_id, event_type, char_index, message);
   }
 
  private:
   bool should_fake_get_voices_;
   base::WeakPtrFactory<MockTtsPlatformImpl> ptr_factory_;
@@ skipping 280 matching lines @@
   // Test should fail when offline.
   ASSERT_FALSE(RunExtensionTest("tts_engine/network_speech_engine"));
 }
 
 // http://crbug.com/122474
 IN_PROC_BROWSER_TEST_F(TtsApiTest, EngineApi) {
   ASSERT_TRUE(RunExtensionTest("tts_engine/engine_api")) << message_;
 }
 
 }  // namespace extensions