ash: Do not use MessageLoopForUI when not needed.

ash/accelerators/key_hold_detector.cc

 // Copyright 2014 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 "ash/accelerators/key_hold_detector.h"
 
 #include <utility>
 
 #include "ash/shell.h"
-#include "base/message_loop/message_loop.h"
+#include "base/thread_task_runner_handle.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/events/event_dispatcher.h"
 #include "ui/events/event_processor.h"
 
 namespace ash {
 namespace {
 
 void DispatchPressedEvent(const ui::KeyEvent& key_event,
                           scoped_ptr<aura::WindowTracker> tracker) {
   // The target window may be gone.
   if (tracker->windows().empty())
     return;
   ui::KeyEvent event(key_event);
   aura::Window* target = *(tracker->windows().begin());
   ignore_result(
       target->GetHost()->event_processor()->OnEventFromSource(&event));
 }
 
 void PostPressedEvent(ui::KeyEvent* event) {
   // Modify RELEASED event to PRESSED event.
   const ui::KeyEvent pressed_event(
       ui::ET_KEY_PRESSED,
       event->key_code(),
       event->code(),
       event->flags() | ui::EF_SHIFT_DOWN | ui::EF_IS_SYNTHESIZED);
   scoped_ptr<aura::WindowTracker> tracker(new aura::WindowTracker);
   tracker->Add(static_cast<aura::Window*>(event->target()));
 
-  base::MessageLoopForUI::current()->PostTask(

[oshima, 2016/01/27 22:23:53]

My understanding was that we used to use MessageLoopForUI::current() as a safe
guard to make sure that UI code runs on single UI thread.

I understand that it does not really have to be "UI thread" in new world, but
still should be single thread. Is there a way to make sure they runs on the same
single thread?

[sadrul, 2016/01/27 23:44:02]

ThreadTaskRunnerHandle::Get() returns the task-runner for the current thread,
and it's a SingleThreadTaskRunner instance. So we are guaranteed to run the task
(i.e. DispatchPressedEvent) in the same thread as this code (i.e.
PostPressedEvent).

Is that what you mean? We can also use base::ThreadChecker to verify that parts
of the code are running in the thread we expect, but it's not clear where we
would use that in this case.

+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&DispatchPressedEvent, pressed_event, base::Passed(&tracker)));
 }
 
 }  // namespace
 
 KeyHoldDetector::KeyHoldDetector(scoped_ptr<Delegate> delegate)
     : state_(INITIAL), delegate_(std::move(delegate)) {}
 
 KeyHoldDetector::~KeyHoldDetector() {}
@@ skipping 42 matching lines @@
         if (delegate_->ShouldStopEventPropagation())
           event->StopPropagation();
         break;
       }
     }
     state_ = INITIAL;
   }
 }
 
 }  // namespace ash