Set up the message loop of the mac host to be UI based so that it can pick up...

remoting/host/simple_host.cc

 // Copyright (c) 2010 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 "remoting/host/simple_host.h"
 
 #include "base/stl_util-inl.h"
 #include "build/build_config.h"
 #include "remoting/base/protocol_decoder.h"
 #include "remoting/host/session_manager.h"
 #include "remoting/jingle_glue/jingle_channel.h"
 
 namespace remoting {
 
+#if defined (OS_MACOSX)
+// The Mac depends on system callbacks to tell it what rectangles need to
+// be updated, so we need to use the system message loop.
+const MessageLoop::Type kSimpleHostMessageLoopType = MessageLoop::TYPE_UI;
+#else
+const MessageLoop::Type kSimpleHostMessageLoopType = MessageLoop::TYPE_DEFAULT;
+#endif //  defined (OS_MACOSX)
+
 SimpleHost::SimpleHost(const std::string& username,
                        const std::string& password,
                        Capturer* capturer,
                        Encoder* encoder,
                        EventExecutor* executor)
-      : capture_thread_("CaptureThread"),
+      : main_loop_(kSimpleHostMessageLoopType),
+        capture_thread_("CaptureThread"),
         encode_thread_("EncodeThread"),
         username_(username),
         password_(password),
         capturer_(capturer),
         encoder_(encoder),
         executor_(executor) {
 }
 
 void SimpleHost::Run() {
   DCHECK_EQ(&main_loop_, MessageLoop::current());
 
   // Submit a task to perform host registration. We'll also start
   // listening to connection if registration is done.
   RegisterHost();
 
   // Run the main message loop. This is the main loop of this host
   // object.
   main_loop_.Run();
 }
 
-// This method is called when we need to the host process.
+// This method is called when we need to destroy the host process.
 void SimpleHost::DestroySession() {
   DCHECK_EQ(&main_loop_, MessageLoop::current());
 
   // First we tell the session to pause and then we wait until all
   // the tasks are done.
   session_->Pause();
 
   // TODO(hclam): Revise the order.
   encode_thread_.Stop();
   capture_thread_.Stop();
@@ skipping 46 matching lines @@
 void SimpleHost::OnClientDisconnected(ClientConnection* client) {
   DCHECK_EQ(&main_loop_, MessageLoop::current());
 
   // Remove the client from the session manager.
   DCHECK(session_);
   session_->RemoveClient(client);
 
   // Also remove reference to ClientConnection from this object.
   client_ = NULL;
 
-  // TODO(hclam): If the last client has disconnected we need destroy
+  // TODO(hclam): If the last client has disconnected we need to destroy
   // the session manager and shutdown the capture and encode threads.
-  // Right now we assume there's only one client.
+  // Right now we assume that there's only one client.
   DestroySession();
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // ClientConnection::EventHandler implementations
 void SimpleHost::HandleMessages(ClientConnection* client,
                                 ClientMessageList* messages) {
   DCHECK_EQ(&main_loop_, MessageLoop::current());
 
   // Delegate the messages to EventExecutor and delete the unhandled
@@ skipping 71 matching lines @@
                                  scoped_refptr<JingleChannel> channel) {
   DCHECK_EQ(jingle_client_.get(), jingle_client);
 
   // Since the session manager has not started, it is still safe to access
   // the client directly. Note that we give the ownership of the channel
   // to the client.
   client_->set_jingle_channel(channel);
 }
 
 }  // namespace remoting