Chrome changes corresponding to my message_loop_type CL.

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

11 files changed, 67 insertions, 53 deletions

diff --git a/chrome/common/animation_unittest.cc b/chrome/common/animation_unittest.cc
index e4429cd..3f9da3c 100644
--- a/chrome/common/animation_unittest.cc
+++ b/chrome/common/animation_unittest.cc
@@ -11,6 +11,8 @@ using namespace std;
 
 namespace {
   class AnimationTest: public testing::Test {
+   private:
+    MessageLoopForUI message_loop_;
   };
 };
 
@@ -81,7 +83,7 @@ class TestAnimationDelegate : public AnimationDelegate {
   bool canceled_;
 };
 
-TEST(AnimationTest, RunCase) {
+TEST_F(AnimationTest, RunCase) {
   TestAnimationDelegate ad;
   RunAnimation a1(150, &ad);
   a1.SetDuration(2000);
@@ -92,7 +94,7 @@ TEST(AnimationTest, RunCase) {
   EXPECT_FALSE(ad.canceled());
 }
 
-TEST(AnimationTest, CancelCase) {
+TEST_F(AnimationTest, CancelCase) {
   TestAnimationDelegate ad;
   CancelAnimation a2(2000, 150, &ad);
   a2.Start();
diff --git a/chrome/common/chrome_plugin_unittest.cc b/chrome/common/chrome_plugin_unittest.cc
index 139bcf4..f998755 100644
--- a/chrome/common/chrome_plugin_unittest.cc
+++ b/chrome/common/chrome_plugin_unittest.cc
@@ -62,6 +62,8 @@ class ChromePluginTest : public testing::Test, public URLRequest::Delegate {
     Profile::set_default_request_context(NULL);
   }
  protected:
+  MessageLoopForIO message_loop_;
+
   // Note: we use URLRequest (instead of URLFetcher) because this allows the
   // request to be intercepted.
   scoped_ptr<URLRequest> request_;
diff --git a/chrome/common/chrome_plugin_util.cc b/chrome/common/chrome_plugin_util.cc
index 1a33990..56b1f54 100644
--- a/chrome/common/chrome_plugin_util.cc
+++ b/chrome/common/chrome_plugin_util.cc
@@ -46,18 +46,14 @@ void PluginHelper::DestroyAllHelpersForPlugin(ChromePluginLib* plugin) {
 }
 
 PluginHelper::PluginHelper(ChromePluginLib* plugin) : plugin_(plugin) {
-#ifndef NDEBUG
-  message_loop_ = MessageLoop::current();
-#endif
+  DCHECK(CalledOnValidThread());
   NotificationService::current()->AddObserver(
       this, NOTIFY_CHROME_PLUGIN_UNLOADED,
       Source<ChromePluginLib>(plugin_));
 }
 
 PluginHelper::~PluginHelper() {
-#ifndef NDEBUG
-  DCHECK(MessageLoop::current() == message_loop_);
-#endif
+  DCHECK(CalledOnValidThread());
   NotificationService::current()->RemoveObserver(
       this, NOTIFY_CHROME_PLUGIN_UNLOADED,
       Source<ChromePluginLib>(plugin_));
@@ -66,9 +62,7 @@ PluginHelper::~PluginHelper() {
 void PluginHelper::Observe(NotificationType type,
                            const NotificationSource& source,
                            const NotificationDetails& details) {
-#ifndef NDEBUG
-  DCHECK(MessageLoop::current() == message_loop_);
-#endif
+  DCHECK(CalledOnValidThread());
   DCHECK(type == NOTIFY_CHROME_PLUGIN_UNLOADED);
   DCHECK(plugin_ == Source<ChromePluginLib>(source).ptr());
 
diff --git a/chrome/common/chrome_plugin_util.h b/chrome/common/chrome_plugin_util.h
index 847e096..5ca17fc 100644
--- a/chrome/common/chrome_plugin_util.h
+++ b/chrome/common/chrome_plugin_util.h
@@ -6,6 +6,7 @@
 #define CHROME_COMMON_CHROME_PLUGIN_UTIL_H__
 
 #include "base/basictypes.h"
+#include "base/non_thread_safe.h"
 #include "base/ref_counted.h"
 #include "chrome/common/chrome_plugin_api.h"
 #include "chrome/common/notification_service.h"
@@ -35,7 +36,7 @@ struct ScopableCPRequest : public CPRequest {
 // This is a base class for plugin-related objects that need to go away when
 // the plugin unloads.  This object also verifies that it is created and
 // destroyed on the same thread.
-class PluginHelper : public NotificationObserver {
+class PluginHelper : public NotificationObserver, public NonThreadSafe {
  public:
   static void DestroyAllHelpersForPlugin(ChromePluginLib* plugin);
 
@@ -49,11 +50,6 @@ class PluginHelper : public NotificationObserver {
 
  protected:
   scoped_refptr<ChromePluginLib> plugin_;
-#ifndef NDEBUG
-  // We keep track of the message loop of the thread we were created on, so
-  // we can verify that all other methods are called on the same thread.
-  MessageLoop* message_loop_;
-#endif
 
   DISALLOW_EVIL_CONSTRUCTORS(PluginHelper);
 };
diff --git a/chrome/common/ipc_channel.cc b/chrome/common/ipc_channel.cc
index 40a101b..c87d75f 100644
--- a/chrome/common/ipc_channel.cc
+++ b/chrome/common/ipc_channel.cc
@@ -49,8 +49,9 @@ Channel::Channel(const wstring& channel_id, Mode mode, Listener* listener)
 
 void Channel::Close() {
   // make sure we are no longer watching the pipe events
-  MessageLoop::current()->WatchObject(input_state_.overlapped.hEvent, NULL);
-  MessageLoop::current()->WatchObject(output_state_.overlapped.hEvent, NULL);
+  MessageLoopForIO* loop = MessageLoopForIO::current();
+  loop->WatchObject(input_state_.overlapped.hEvent, NULL);
+  loop->WatchObject(output_state_.overlapped.hEvent, NULL);
 
   if (pipe_ != INVALID_HANDLE_VALUE) {
     CloseHandle(pipe_);
@@ -168,7 +169,8 @@ bool Channel::Connect() {
     // to OnObjectSignaled that this is the special initialization signal.
 
     SetEvent(input_state_.overlapped.hEvent);
-    MessageLoop::current()->WatchObject(input_state_.overlapped.hEvent, this);
+    MessageLoopForIO::current()->WatchObject(
+        input_state_.overlapped.hEvent, this);
   }
 
   if (!waiting_connect_)
@@ -178,7 +180,8 @@ bool Channel::Connect() {
 
 bool Channel::ProcessConnection() {
   input_state_.is_pending = false;
-  MessageLoop::current()->WatchObject(input_state_.overlapped.hEvent, NULL);
+  MessageLoopForIO::current()->WatchObject(
+      input_state_.overlapped.hEvent, NULL);
 
   // Do we have a client connected to our pipe?
   DCHECK(pipe_ != INVALID_HANDLE_VALUE);
@@ -195,7 +198,8 @@ bool Channel::ProcessConnection() {
   switch (err) {
   case ERROR_IO_PENDING:
     input_state_.is_pending = true;
-    MessageLoop::current()->WatchObject(input_state_.overlapped.hEvent, this);
+    MessageLoopForIO::current()->WatchObject(
+        input_state_.overlapped.hEvent, this);
     break;
   case ERROR_PIPE_CONNECTED:
     waiting_connect_ = false;
@@ -211,7 +215,8 @@ bool Channel::ProcessConnection() {
 bool Channel::ProcessIncomingMessages() {
   DWORD bytes_read = 0;
 
-  MessageLoop::current()->WatchObject(input_state_.overlapped.hEvent, NULL);
+  MessageLoopForIO::current()->WatchObject(
+      input_state_.overlapped.hEvent, NULL);
 
   if (input_state_.is_pending) {
     input_state_.is_pending = false;
@@ -243,8 +248,8 @@ bool Channel::ProcessIncomingMessages() {
       if (!ok) {
         DWORD err = GetLastError();
         if (err == ERROR_IO_PENDING) {
-          MessageLoop::current()->WatchObject(input_state_.overlapped.hEvent,
-                                              this);
+          MessageLoopForIO::current()->WatchObject(
+              input_state_.overlapped.hEvent, this);
           input_state_.is_pending = true;
           return true;
         }
@@ -307,7 +312,8 @@ bool Channel::ProcessOutgoingMessages() {
   DWORD bytes_written;
 
   if (output_state_.is_pending) {
-    MessageLoop::current()->WatchObject(output_state_.overlapped.hEvent, NULL);
+    MessageLoopForIO::current()->WatchObject(
+        output_state_.overlapped.hEvent, NULL);
     output_state_.is_pending = false;
     BOOL ok = GetOverlappedResult(pipe_,
                                   &output_state_.overlapped,
@@ -336,8 +342,8 @@ bool Channel::ProcessOutgoingMessages() {
     if (!ok) {
       DWORD err = GetLastError();
       if (err == ERROR_IO_PENDING) {
-        MessageLoop::current()->WatchObject(output_state_.overlapped.hEvent,
-                                            this);
+        MessageLoopForIO::current()->WatchObject(
+            output_state_.overlapped.hEvent, this);
         output_state_.is_pending = true;
 
 #ifdef IPC_MESSAGE_DEBUG_EXTRA
diff --git a/chrome/common/ipc_channel.h b/chrome/common/ipc_channel.h
index 549e9cb..94d41a3 100644
--- a/chrome/common/ipc_channel.h
+++ b/chrome/common/ipc_channel.h
@@ -14,7 +14,7 @@ namespace IPC {
 
 //------------------------------------------------------------------------------
 
-class Channel : public MessageLoop::Watcher,
+class Channel : public MessageLoopForIO::Watcher,
                 public Message::Sender {
   // Security tests need access to the pipe handle.
   friend class ChannelTest;
diff --git a/chrome/common/ipc_sync_channel_unittest.cc b/chrome/common/ipc_sync_channel_unittest.cc
index f930790..3899204 100644
--- a/chrome/common/ipc_sync_channel_unittest.cc
+++ b/chrome/common/ipc_sync_channel_unittest.cc
@@ -97,12 +97,13 @@ class Worker : public Channel::Listener, public Message::Sender {
   void WaitForChannelCreation() { channel_created_.Wait(); }
   void CloseChannel() { channel_.reset(); }
   void Start() {
-    listener_thread_.Start();
-    Thread* thread = overrided_thread_ ? overrided_thread_ : &listener_thread_;
+    StartThread(&listener_thread_);
+    base::Thread* thread =
+        overrided_thread_ ? overrided_thread_ : &listener_thread_;
     thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
         this, &Worker::OnStart));
   }
-  void OverrideThread(Thread* overrided_thread) {
+  void OverrideThread(base::Thread* overrided_thread) {
     DCHECK(overrided_thread_ == NULL);
     overrided_thread_ = overrided_thread;
   }
@@ -133,8 +134,8 @@ class Worker : public Channel::Listener, public Message::Sender {
  private:
   // Called on the listener thread to create the sync channel.
   void OnStart() {
-    ipc_thread_.Start();
     // Link ipc_thread_, listener_thread_ and channel_ altogether.
+    StartThread(&ipc_thread_);
     channel_.reset(new SyncChannel(
         channel_name_, mode_, this, NULL, ipc_thread_.message_loop(), true,
         TestProcess::GetShutDownEvent()));
@@ -150,14 +151,20 @@ class Worker : public Channel::Listener, public Message::Sender {
     IPC_END_MESSAGE_MAP()
   }
 
+  void StartThread(base::Thread* thread) {
+    base::Thread::Options options;
+    options.message_loop_type = MessageLoop::TYPE_IO;
+    thread->StartWithOptions(options);
+  }
+
   Event done_;
   Event channel_created_;
   std::wstring channel_name_;
   Channel::Mode mode_;
   scoped_ptr<SyncChannel> channel_;
-  Thread ipc_thread_;
-  Thread listener_thread_;
-  Thread* overrided_thread_;
+  base::Thread ipc_thread_;
+  base::Thread listener_thread_;
+  base::Thread* overrided_thread_;
 
   DISALLOW_EVIL_CONSTRUCTORS(Worker);
 };
@@ -191,6 +198,8 @@ void RunTest(std::vector<Worker*> workers) {
   int count = static_cast<int>(done_handles.size());
   WaitForMultipleObjects(count, &done_handles.front(), TRUE, INFINITE);
   STLDeleteContainerPointers(workers.begin(), workers.end());
+  
+  TestProcess::GlobalCleanup();
 }
 
 
@@ -403,7 +412,7 @@ TEST(IPCSyncChannelTest, Multiple) {
   std::vector<Worker*> workers;
 
   // A shared worker thread so that server1 and server2 run on one thread.
-  Thread worker_thread("Multiple");
+  base::Thread worker_thread("Multiple");
   worker_thread.Start();
 
   // Server1 sends a sync msg to client1, which blocks the reply until
@@ -510,7 +519,7 @@ TEST(IPCSyncChannelTest, QueuedReply) {
   std::vector<Worker*> workers;
 
   // A shared worker thread so that server1 and server2 run on one thread.
-  Thread worker_thread("QueuedReply");
+  base::Thread worker_thread("QueuedReply");
   worker_thread.Start();
 
   Event client1_msg_received, server2_can_reply;
diff --git a/chrome/common/ipc_tests.cc b/chrome/common/ipc_tests.cc
index 316c397..67d7140 100644
--- a/chrome/common/ipc_tests.cc
+++ b/chrome/common/ipc_tests.cc
@@ -133,8 +133,10 @@ TEST(IPCChannelTest, ChannelTest) {
 
 TEST(IPCChannelTest, ChannelProxyTest) {
   // The thread needs to out-live the ChannelProxy.
-  Thread thread("ChannelProxyTestServer");
-  thread.Start();
+  base::Thread thread("ChannelProxyTestServer");
+  base::Thread::Options options;
+  options.message_loop_type = MessageLoop::TYPE_IO;
+  thread.StartWithOptions(options);
   {
     // setup IPC channel proxy
     IPC::ChannelProxy chan(kTestClientChannel, IPC::Channel::MODE_SERVER,
@@ -380,7 +382,7 @@ int main(int argc, char** argv) {
   // the AtExitManager or else we will leak objects.
   base::AtExitManager at_exit_manager;  
 
-  MessageLoop main_message_loop;
+  MessageLoopForIO main_message_loop;
 
   // suppress standard crash dialogs and such unless a debugger is present.
   if (!IsDebuggerPresent()) {
diff --git a/chrome/common/pref_service.cc b/chrome/common/pref_service.cc
index dd55bdc..60ac6f2 100644
--- a/chrome/common/pref_service.cc
+++ b/chrome/common/pref_service.cc
@@ -178,7 +178,7 @@ void PrefService::ReloadPersistentPrefs() {
   }
 }
 
-bool PrefService::SavePersistentPrefs(Thread* thread) const {
+bool PrefService::SavePersistentPrefs(base::Thread* thread) const {
   DCHECK(!pref_filename_.empty());
   DCHECK(CalledOnValidThread());
 
@@ -202,7 +202,7 @@ bool PrefService::SavePersistentPrefs(Thread* thread) const {
   return true;
 }
 
-void PrefService::ScheduleSavePersistentPrefs(Thread* thread) {
+void PrefService::ScheduleSavePersistentPrefs(base::Thread* thread) {
   if (!save_preferences_factory_.empty())
     return;
 
diff --git a/chrome/common/pref_service.h b/chrome/common/pref_service.h
index 9b552f2..32c012f 100644
--- a/chrome/common/pref_service.h
+++ b/chrome/common/pref_service.h
@@ -28,7 +28,10 @@
 
 class NotificationObserver;
 class Preference;
+
+namespace base {
 class Thread;
+}
 
 class PrefService : public NonThreadSafe {
  public:
@@ -88,12 +91,12 @@ class PrefService : public NonThreadSafe {
   // (since it's on a different thread).  This should only be used if we need
   // to save immediately (basically, during shutdown).  Otherwise, you should
   // use ScheduleSavePersistentPrefs.
-  bool SavePersistentPrefs(Thread* thread) const;
+  bool SavePersistentPrefs(base::Thread* thread) const;
 
   // Starts a timer that ends up saving the preferences.  This helps to batch
   // together save requests that happen in a close time frame so we don't write
   // to disk too frequently.
-  void ScheduleSavePersistentPrefs(Thread* thread);
+  void ScheduleSavePersistentPrefs(base::Thread* thread);
 
   DictionaryValue* transient() { return transient_.get(); }
 
diff --git a/chrome/common/process_watcher.cc b/chrome/common/process_watcher.cc
index 8a9fadc..b8d78bd2 100644
--- a/chrome/common/process_watcher.cc
+++ b/chrome/common/process_watcher.cc
@@ -5,6 +5,7 @@
 #include "chrome/common/process_watcher.h"
 
 #include "base/message_loop.h"
+#include "base/object_watcher.h"
 #include "chrome/app/result_codes.h"
 #include "chrome/common/env_util.h"
 #include "chrome/common/env_vars.h"
@@ -14,10 +15,10 @@ static const int kWaitInterval = 2000;
 
 namespace {
 
-class TimerExpiredTask : public Task, public MessageLoop::Watcher {
+class TimerExpiredTask : public Task, public base::ObjectWatcher::Delegate {
  public:
   explicit TimerExpiredTask(ProcessHandle process) : process_(process) {
-    MessageLoop::current()->WatchObject(process_, this);
+    watcher_.StartWatching(process_, this);
   }
 
   virtual ~TimerExpiredTask() {
@@ -37,12 +38,9 @@ class TimerExpiredTask : public Task, public MessageLoop::Watcher {
   // MessageLoop::Watcher -----------------------------------------------------
 
   virtual void OnObjectSignaled(HANDLE object) {
-    if (MessageLoop::current()) {
-      // When we're called from our destructor, the message loop is in the
-      // process of being torn down.  Only touch the message loop if it is
-      // still running.
-      MessageLoop::current()->WatchObject(process_, NULL);  // Stop watching.
-    }
+    // When we're called from KillProcess, the ObjectWatcher may still be
+    // watching.  the process handle, so make sure it has stopped.
+    watcher_.StopWatching();
 
     CloseHandle(process_);
     process_ = NULL;
@@ -72,6 +70,8 @@ class TimerExpiredTask : public Task, public MessageLoop::Watcher {
   // The process that we are watching.
   ProcessHandle process_;
 
+  base::ObjectWatcher watcher_;
+
   DISALLOW_EVIL_CONSTRUCTORS(TimerExpiredTask);
 };