Nukes MessageLoop::Dispatcher

base/run_loop.h

 // 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.
 
 #ifndef BASE_RUN_LOOP_H_
 #define BASE_RUN_LOOP_H_
 
 #include "base/base_export.h"
 #include "base/callback.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 
 namespace base {
 #if defined(OS_ANDROID)
 class MessagePumpForUI;
 #endif
 
+#if defined(USE_AURA)
+class MessagePumpDispatcher;
+#endif
+
 #if defined(OS_IOS)
 class MessagePumpUIApplication;
 #endif
 
 // Helper class to Run a nested MessageLoop. Please do not use nested
 // MessageLoops in production code! If you must, use this class instead of
 // calling MessageLoop::Run/Quit directly. RunLoop::Run can only be called once
 // per RunLoop lifetime. Create a RunLoop on the stack and call Run/Quit to run
 // a nested MessageLoop.
 class BASE_EXPORT RunLoop {
  public:
   RunLoop();
 #if defined(USE_AURA)
-  explicit RunLoop(MessageLoop::Dispatcher* dispatcher);
+  explicit RunLoop(MessagePumpDispatcher* dispatcher);
 #endif
   ~RunLoop();
 
 #if defined(USE_AURA)
-  void set_dispatcher(MessageLoop::Dispatcher* dispatcher) {
+  void set_dispatcher(MessagePumpDispatcher* dispatcher) {
     dispatcher_ = dispatcher;
   }
 #endif
 
   // Run the current MessageLoop. This blocks until Quit is called. Before
   // calling Run, be sure to grab an AsWeakPtr or the QuitClosure in order to
   // stop the MessageLoop asynchronously. MessageLoop::Quit and QuitNow will
   // also trigger a return from Run, but those are deprecated.
   void Run();
 
@@ skipping 42 matching lines @@
   // Return false to abort the Run.
   bool BeforeRun();
   void AfterRun();
 
   MessageLoop* loop_;
 
   // Parent RunLoop or NULL if this is the top-most RunLoop.
   RunLoop* previous_run_loop_;
 
 #if defined(USE_AURA)
-  MessageLoop::Dispatcher* dispatcher_;
+  MessagePumpDispatcher* dispatcher_;
 #endif
 
   // Used to count how many nested Run() invocations are on the stack.
   int run_depth_;
 
   bool run_called_;
   bool quit_called_;
   bool running_;
 
   // Used to record that QuitWhenIdle() was called on the MessageLoop, meaning
   // that we should quit Run once it becomes idle.
   bool quit_when_idle_received_;
 
   // WeakPtrFactory for QuitClosure safety.
   base::WeakPtrFactory<RunLoop> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RunLoop);
 };
 
 }  // namespace base
 
 #endif  // BASE_RUN_LOOP_H_