Revert of Version of MessagePumpForUI optimized for GPU process

base/message_loop/message_pump_win.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_MESSAGE_LOOP_MESSAGE_PUMP_WIN_H_
 #define BASE_MESSAGE_LOOP_MESSAGE_PUMP_WIN_H_
 
 #include <windows.h>
 
 #include <list>
-#include <memory>
 
 #include "base/base_export.h"
 #include "base/message_loop/message_pump.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
 #include "base/win/scoped_handle.h"
 
 namespace base {
 
 // MessagePumpWin serves as the base for specialized versions of the MessagePump
 // for Windows. It provides basic functionality like handling of observers and
 // controlling the lifetime of the message pump.
 class BASE_EXPORT MessagePumpWin : public MessagePump {
  public:
-  MessagePumpWin() : work_state_(READY), state_(NULL) {}
+  MessagePumpWin() : have_work_(0), state_(NULL) {}
 
   // MessagePump methods:
   void Run(Delegate* delegate) override;
   void Quit() override;
 
  protected:
   struct RunState {
     Delegate* delegate;
 
     // Used to flag that the current Run() invocation should return ASAP.
     bool should_quit;
 
     // Used to count how many Run() invocations are on the stack.
     int run_depth;
   };
 
-  // State used with |work_state_| variable.
-  enum WorkState {
-    READY = 0,      // Ready to accept new work.
-    HAVE_WORK = 1,  // New work has been signalled.
-    WORKING = 2     // Handling the work.
-  };
-
   virtual void DoRunLoop() = 0;
   int GetCurrentDelay() const;
 
   // The time at which delayed work should run.
   TimeTicks delayed_work_time_;
 
-  // A value used to indicate if there is a kMsgDoWork message pending
+  // A boolean value used to indicate if there is a kMsgDoWork message pending
   // in the Windows Message queue.  There is at most one such message, and it
   // can drive execution of tasks when a native message pump is running.
-  LONG work_state_;
+  LONG have_work_;
 
   // State for the current invocation of Run.
   RunState* state_;
 };
 
 //-----------------------------------------------------------------------------
 // MessagePumpForUI extends MessagePumpWin with methods that are particular to a
 // MessageLoop instantiated with TYPE_UI.
 //
 // MessagePumpForUI implements a "traditional" Windows message pump. It contains
@@ skipping 35 matching lines @@
 // is peeked, and before a replacement kMsgHaveWork is posted).
 //
 // NOTE: Although it may seem odd that messages are used to start and stop this
 // flow (as opposed to signaling objects, etc.), it should be understood that
 // the native message pump will *only* respond to messages.  As a result, it is
 // an excellent choice.  It is also helpful that the starter messages that are
 // placed in the queue when new task arrive also awakens DoRunLoop.
 //
 class BASE_EXPORT MessagePumpForUI : public MessagePumpWin {
  public:
+  // The application-defined code passed to the hook procedure.
+  static const int kMessageFilterCode = 0x5001;
+
   MessagePumpForUI();
   ~MessagePumpForUI() override;
 
   // MessagePump methods:
   void ScheduleWork() override;
   void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override;
 
  private:
   static LRESULT CALLBACK WndProcThunk(HWND window_handle,
                                        UINT message,
@@ skipping 10 matching lines @@
   bool ProcessPumpReplacementMessage();
 
   // Atom representing the registered window class.
   ATOM atom_;
 
   // A hidden message-only window.
   HWND message_hwnd_;
 };
 
 //-----------------------------------------------------------------------------
-// MessagePumpForGpu is a simplified version of UI message pump that is
-// optimized for the GPU process. Unlike MessagePumpForUI it doesn't have a
-// hidden window and doesn't handle a situation where a native message pump
-// might take over message processing.
-//
-class BASE_EXPORT MessagePumpForGpu : public MessagePumpWin {
- public:
-  MessagePumpForGpu();
-  ~MessagePumpForGpu() override;
-
-  // Factory methods.
-  static void InitFactory();
-  static std::unique_ptr<MessagePump> CreateMessagePumpForGpu();
-
-  // MessagePump methods:
-  void ScheduleWork() override;
-  void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override;
-
- private:
-  // MessagePumpWin methods:
-  void DoRunLoop() override;
-
-  void WaitForWork();
-  bool ProcessMessages();
-
-  const DWORD thread_id_;
-};
-
-//-----------------------------------------------------------------------------
 // MessagePumpForIO extends MessagePumpWin with methods that are particular to a
 // MessageLoop instantiated with TYPE_IO. This version of MessagePump does not
 // deal with Windows mesagges, and instead has a Run loop based on Completion
 // Ports so it is better suited for IO operations.
 //
 class BASE_EXPORT MessagePumpForIO : public MessagePumpWin {
  public:
   struct IOContext;
 
   // Clients interested in receiving OS notifications when asynchronous IO
@@ skipping 176 matching lines @@
   // This list will be empty almost always. It stores IO completions that have
   // not been delivered yet because somebody was doing cleanup.
   std::list<IOItem> completed_io_;
 
   ObserverList<IOObserver> io_observers_;
 };
 
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_MESSAGE_PUMP_WIN_H_