Remove use of deprecated MessageLoop methods in ui.

ui/base/win/osk_display_manager.cc

 // Copyright 2016 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 "ui/base/win/osk_display_manager.h"
 
 #include <windows.h>
 #include <shellapi.h>
 #include <shlobj.h>
 #include <shobjidl.h>  // Must be before propkey.
 
 #include "base/bind.h"
 #include "base/debug/leak_annotations.h"
+#include "base/location.h"
 #include "base/logging.h"
-#include "base/message_loop/message_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/win_util.h"
 #include "base/win/windows_version.h"
 #include "ui/base/win/osk_display_observer.h"
 #include "ui/display/win/dpi.h"
 #include "ui/gfx/geometry/dip_util.h"
 
 namespace {
 
@@ skipping 88 matching lines @@
 OnScreenKeyboardDetector::~OnScreenKeyboardDetector() {}
 
 void OnScreenKeyboardDetector::DetectKeyboard(HWND main_window) {
   main_window_ = main_window;
   keyboard_detect_requested_ = true;
   // The keyboard is displayed by TabTip.exe which is launched via a
   // ShellExecute call in the
   // OnScreenKeyboardDisplayManager::DisplayVirtualKeyboard() function. We use
   // a delayed task to check if the keyboard is visible because of the possible
   // delay between the ShellExecute call and the keyboard becoming visible.
-  base::MessageLoop::current()->PostDelayedTask(
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&OnScreenKeyboardDetector::CheckIfKeyboardVisible,
                             keyboard_detector_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kCheckOSKDelayMs));
 }
 
 bool OnScreenKeyboardDetector::DismissKeyboard() {
   // We dismiss the virtual keyboard by generating the ESC keystroke
   // programmatically.
   HWND osk = ::FindWindow(kOSKClassName, nullptr);
   if (::IsWindow(osk) && ::IsWindowEnabled(osk)) {
     keyboard_detect_requested_ = false;
     keyboard_dismiss_retry_count_ = 0;
     HandleKeyboardHidden();
     PostMessage(osk, WM_SYSCOMMAND, SC_CLOSE, 0);
     return true;
   } else if (keyboard_detect_requested_) {
     if (keyboard_dismiss_retry_count_ < kDismissKeyboardMaxRetries) {
       keyboard_dismiss_retry_count_++;
       // Please refer to the comments in the DetectKeyboard() function for more
       // information as to why we need a delayed task here.
-      base::MessageLoop::current()->PostDelayedTask(
+      base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
           FROM_HERE, base::Bind(base::IgnoreResult(
                                     &OnScreenKeyboardDetector::DismissKeyboard),
                                 keyboard_detector_factory_.GetWeakPtr()),
           base::TimeDelta::FromMilliseconds(kDismissKeyboardRetryTimeoutMs));
     } else {
       keyboard_dismiss_retry_count_ = 0;
     }
   }
   return false;
 }
@@ skipping 42 matching lines @@
         DVLOG(1) << "OSK window hidden while we are in the foreground.";
         HandleKeyboardHidden();
       }
     }
   } else if (main_window_ != ::GetForegroundWindow()) {
     if (osk_visible_notification_received_) {
       DVLOG(1) << "We are no longer in the foreground. Dismising OSK.";
       DismissKeyboard();
     }
   } else {
-    base::MessageLoop::current()->PostDelayedTask(
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::Bind(&OnScreenKeyboardDetector::HideIfNecessary,
                               keyboard_detector_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(kCheckOSKDelayMs));
   }
 }
 
 void OnScreenKeyboardDetector::HandleKeyboardVisible() {
   DCHECK(!osk_visible_notification_received_);
   osk_visible_notification_received_ = true;
 
   FOR_EACH_OBSERVER(OnScreenKeyboardObserver, observers_,
                     OnKeyboardVisible(osk_rect_pixels_));
 
   // Now that the keyboard is visible, run the task to detect if it was hidden.
-  base::MessageLoop::current()->PostDelayedTask(
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&OnScreenKeyboardDetector::HideIfNecessary,
                             keyboard_detector_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kCheckOSKDelayMs));
 }
 
 void OnScreenKeyboardDetector::HandleKeyboardHidden() {
   osk_visible_notification_received_ = false;
   FOR_EACH_OBSERVER(OnScreenKeyboardObserver, observers_,
                     OnKeyboardHidden(osk_rect_pixels_));
   ClearObservers();
@@ skipping 120 matching lines @@
         return false;
       }
       common_program_files_path = common_program_files;
     }
     osk_path->insert(common_program_files_offset, common_program_files_path);
   }
   return !osk_path->empty();
 }
 
 }  // namespace ui