just some hopefully non-contentious stuff to get out of the way before doing the real MessageLoop changes.

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@459 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 55 insertions, 40 deletions

diff --git a/base/message_loop.h b/base/message_loop.h
index cd7b1c5..9ce0b8a 100644
--- a/base/message_loop.h
+++ b/base/message_loop.h
@@ -30,7 +30,6 @@
 #ifndef BASE_MESSAGE_LOOP_H__
 #define BASE_MESSAGE_LOOP_H__
 
-#include <windows.h>
 #include <deque>
 #include <queue>
 #include <string>
@@ -141,6 +140,7 @@ class MessageLoop {
   static void SetStrategy(int strategy);
   static void EnableHistogrammer(bool enable_histogrammer);
 
+#ifdef OS_WIN
   // Used with WatchObject to asynchronously monitor the signaled state of a
   // HANDLE object.
   class Watcher {
@@ -154,6 +154,36 @@ class MessageLoop {
   // Pass a null watcher to stop watching the object.
   bool WatchObject(HANDLE, Watcher*);
 
+  // An Observer is an object that receives global notifications from the
+  // MessageLoop.
+  //
+  // NOTE: An Observer implementation should be extremely fast!
+  //
+  class Observer {
+   public:
+    virtual ~Observer() {}
+
+    // This method is called before processing a message.
+    // The message may be undefined in which case msg.message is 0
+    virtual void WillProcessMessage(const MSG& msg) = 0;
+
+    // This method is called when control returns from processing a UI message.
+    // The message may be undefined in which case msg.message is 0
+    virtual void DidProcessMessage(const MSG& msg) = 0;
+  };
+
+  // Add an Observer, which will start receiving notifications immediately.
+  void AddObserver(Observer* observer);
+
+  // Remove an Observer.  It is safe to call this method while an Observer is
+  // receiving a notification callback.
+  void RemoveObserver(Observer* observer);
+
+  // Give a chance to code processing additional messages to notify the
+  // message loop observers that another message has been processed.
+  void WillProcessMessage(const MSG& msg);
+  void DidProcessMessage(const MSG& msg);
+
   // Dispatcher is used during a nested invocation of Run to dispatch events.
   // If Run is invoked with a non-NULL Dispatcher, MessageLoop does not
   // dispatch events (or invoke TranslateMessage), rather every message is
@@ -175,6 +205,12 @@ class MessageLoop {
     // normal. If false is returned, the nested loop exits immediately.
     virtual bool Dispatch(const MSG& msg) = 0;
   };
+#else  // !OS_WIN
+  // On non-Windows platforms, the Dispatcher does not exist, but we allow the
+  // typename to exist for convenience.  On non-Windows platforms, a Dispatcher
+  // pointer should always be NULL.
+  class Dispatcher;
+#endif  // OS_*
 
   // A DestructionObserver is notified when the current MessageLoop is being
   // destroyed.  These obsevers are notified prior to MessageLoop::current()
@@ -198,31 +234,6 @@ class MessageLoop {
   // DestructionObserver is receiving a notification callback.
   void RemoveDestructionObserver(DestructionObserver* destruction_observer);
 
-  // An Observer is an object that receives global notifications from the
-  // MessageLoop.
-  //
-  // NOTE: An Observer implementation should be extremely fast!
-  //
-  class Observer {
-   public:
-    virtual ~Observer() {}
-
-    // This method is called before processing a message.
-    // The message may be undefined in which case msg.message is 0
-    virtual void WillProcessMessage(const MSG& msg) = 0;
-
-    // This method is called when control returns from processing a UI message.
-    // The message may be undefined in which case msg.message is 0
-    virtual void DidProcessMessage(const MSG& msg) = 0;
-  };
-
-  // Add an Observer, which will start receiving notifications immediately.
-  void AddObserver(Observer* observer);
-
-  // Remove an Observer.  It is safe to call this method while an Observer is
-  // receiving a notification callback.
-  void RemoveObserver(Observer* observer);
-
   // Call the task's Run method asynchronously from within a message loop at
   // some point in the future.  With the PostTask variant, tasks are invoked in
   // FIFO order, inter-mixed with normal UI event processing.  With the
@@ -299,9 +310,6 @@ class MessageLoop {
     }
   };
 
-  // Wnd Proc for message_hwnd_.
-  LRESULT MessageWndProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
-
   // Normally, it is not necessary to instantiate a MessageLoop.  Instead, it
   // is typical to make use of the current thread's MessageLoop instance.
   MessageLoop();
@@ -309,7 +317,7 @@ class MessageLoop {
 
   // Optional call to connect the thread name with this loop.
   void SetThreadName(const std::string& thread_name);
-  std::string thread_name() const { return thread_name_; }
+  const std::string& thread_name() const { return thread_name_; }
 
   // Returns the MessageLoop object for the current thread, or null if none.
   static MessageLoop* current() {
@@ -319,11 +327,6 @@ class MessageLoop {
   // Returns the TimerManager object for the current thread.
   TimerManager* timer_manager() { return &timer_manager_; }
 
-  // Give a chance to code processing additional messages to notify the
-  // message loop delegates that another message has been processed.
-  void WillProcessMessage(const MSG& msg);
-  void DidProcessMessage(const MSG& msg);
-
   // Enables or disables the recursive task processing. This happens in the case
   // of recursive message loops. Some unwanted message loop may occurs when
   // using common controls or printer functions. By default, recursive task
@@ -413,7 +416,7 @@ class MessageLoop {
         : task_(task),
           sequence_number_(sequence_number),
           priority_(task->priority()) {}
-      Task* task() { return task_; }
+      Task* task() const { return task_; }
       bool operator < (PrioritizedTask const & right) const ;
 
      private:
@@ -459,8 +462,15 @@ class MessageLoop {
     DISALLOW_EVIL_CONSTRUCTORS(OptionallyPrioritizedTaskQueue);
   };
 
+#ifdef OS_WIN
   void InitMessageWnd();
 
+  // Windows procedure for message_hwnd_.
+  static LRESULT CALLBACK WndProcThunk(
+      HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
+  LRESULT WndProc(
+      HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
+#endif  // OS_WIN
 
   // A function to encapsulate all the exception handling capability in the
   // stacks around the running of a main message loop.
@@ -490,8 +500,7 @@ class MessageLoop {
   bool ProcessSomeTimers();
 
   //----------------------------------------------------------------------------
-  // Process some pending messages.
-  // Returns true if a message was processed.
+  // Process some pending messages.  Returns true if a message was processed.
   bool ProcessNextWindowsMessage();
 
   // Wait until either an object is signaled, a message is available, a timer
@@ -499,12 +508,14 @@ class MessageLoop {
   // Handle (without returning) any APCs (only IO thread currently has APCs.)
   void WaitForWork();
 
+#ifdef OS_WIN
   // Helper function for processing window messages. This includes handling
   // WM_QUIT, message translation and dispatch, etc.
   //
   // If dispatcher_ is non-NULL this method does NOT dispatch the event, instead
   // it invokes Dispatch on the dispatcher_.
   bool ProcessMessageHelper(const MSG& msg);
+#endif  // OS_WIN
 
   // When we encounter a kMsgPumpATask, the following helper can be called to
   // peek and process a replacement message, such as a WM_PAINT or WM_TIMER.
@@ -566,7 +577,7 @@ class MessageLoop {
   void EnsureMessageGetsPosted(int message) const;
 
   // Post a task to our incomming queue.
-  void MessageLoop::PostTaskInternal(Task* task);
+  void PostTaskInternal(Task* task);
 
   // Start recording histogram info about events and action IF it was enabled
   // and IF the statistics recorder can accept a registration of our histogram.
@@ -593,14 +604,18 @@ class MessageLoop {
   // there was no real prioritization.
   OptionallyPrioritizedTaskQueue work_queue_;
 
+#ifdef OS_WIN
+  HWND message_hwnd_;
+
   // A vector of objects (and corresponding watchers) that are routinely
   // serviced by this message loop's pump.
   std::vector<HANDLE> objects_;
   std::vector<Watcher*> watchers_;
 
   ObserverList<Observer> observers_;
+#endif  // OS_WIN
+
   ObserverList<DestructionObserver> destruction_observers_;
-  HWND message_hwnd_;
   IDMap<Task> timed_tasks_;
   // A recursion block that prevents accidentally running additonal tasks when
   // insider a (accidentally induced?) nested message pump.