Replace PluginMessageLoopProxy with PluginThreadTaskRunner.

remoting/client/plugin/chromoting_instance.cc

 // 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.
 
 #include "remoting/client/plugin/chromoting_instance.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 134 matching lines @@
     LOG(ERROR) << "No valid authentication methods specified.";
     return false;
   }
 
   return true;
 }
 
 ChromotingInstance::ChromotingInstance(PP_Instance pp_instance)
     : pp::Instance(pp_instance),
       initialized_(false),
-      plugin_message_loop_(
-          new PluginMessageLoopProxy(&plugin_thread_delegate_)),
-      context_(plugin_message_loop_),
+      plugin_task_runner_(
+          new PluginThreadTaskRunner(&plugin_thread_delegate_)),
+      context_(plugin_task_runner_),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE | PP_INPUTEVENT_CLASS_WHEEL);
   RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_KEYBOARD);
 
   // Resister this instance to handle debug log messsages.
   RegisterLoggingInstance();
 
   // Send hello message.
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetInteger("apiVersion", kApiVersion);
   data->SetString("apiFeatures", kApiFeatures);
   data->SetInteger("apiMinVersion", kApiMinMessagingVersion);
   PostChromotingMessage("hello", data.Pass());
 }
 
 ChromotingInstance::~ChromotingInstance() {
-  DCHECK(plugin_message_loop_->BelongsToCurrentThread());
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   // Unregister this instance so that debug log messages will no longer be sent
   // to it. This will stop all logging in all Chromoting instances.
   UnregisterLoggingInstance();
 
   // PepperView must be destroyed before the client.
   view_.reset();
 
   if (client_.get()) {
     base::WaitableEvent done_event(true, false);
     client_->Stop(base::Bind(&base::WaitableEvent::Signal,
                              base::Unretained(&done_event)));
     done_event.Wait();
   }
 
   // Stopping the context shuts down all chromoting threads.
   context_.Stop();
 
   // Ensure that nothing touches the plugin thread delegate after this point.
-  plugin_message_loop_->Detach();
+  plugin_task_runner_->Detach();
 }
 
 bool ChromotingInstance::Init(uint32_t argc,
                               const char* argn[],
                               const char* argv[]) {
   CHECK(!initialized_);
   initialized_ = true;
 
   VLOG(1) << "Started ChromotingInstance::Init";
 
@@ skipping 11 matching lines @@
   // which case, there may be a slight race.
   net::EnableSSLServerSockets();
 
   // Start all the threads.
   context_.Start();
 
   // Create the chromoting objects that don't depend on the network connection.
   // RectangleUpdateDecoder runs on a separate thread so for now we wrap
   // PepperView with a ref-counted proxy object.
   scoped_refptr<FrameConsumerProxy> consumer_proxy =
-      new FrameConsumerProxy(plugin_message_loop_);
+      new FrameConsumerProxy(plugin_task_runner_);
   rectangle_decoder_ = new RectangleUpdateDecoder(
       context_.decode_task_runner(), consumer_proxy);
   view_.reset(new PepperView(this, &context_, rectangle_decoder_.get()));
   consumer_proxy->Attach(view_->AsWeakPtr());
 
   return true;
 }
 
 void ChromotingInstance::HandleMessage(const pp::Var& message) {
   if (!message.is_string()) {
@@ skipping 98 matching lines @@
     bool pause = false;
     if (!data->GetBoolean("pause", &pause)) {
       LOG(ERROR) << "Invalid pauseVideo.";
       return;
     }
     PauseVideo(pause);
   }
 }
 
 void ChromotingInstance::DidChangeView(const pp::View& view) {
-  DCHECK(plugin_message_loop_->BelongsToCurrentThread());
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   view_->SetView(view);
 
   if (mouse_input_filter_.get()) {
     mouse_input_filter_->set_input_size(view_->get_view_size_dips());
   }
 }
 
 bool ChromotingInstance::HandleInputEvent(const pp::InputEvent& event) {
-  DCHECK(plugin_message_loop_->BelongsToCurrentThread());
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   if (!IsConnected())
     return false;
 
   // TODO(wez): When we have a good hook into Host dimensions changes, move
   // this there.
   // If |input_handler_| is valid, then |mouse_input_filter_| must also be
   // since they are constructed together as part of the input pipeline
   mouse_input_filter_->set_output_size(view_->get_screen_size());
 
@@ skipping 92 matching lines @@
                              cursor_image,
                              pp::Point(hotspot_x, hotspot_y));
 }
 
 void ChromotingInstance::OnFirstFrameReceived() {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   PostChromotingMessage("onFirstFrameReceived", data.Pass());
 }
 
 void ChromotingInstance::Connect(const ClientConfig& config) {
-  DCHECK(plugin_message_loop_->BelongsToCurrentThread());
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   jingle_glue::JingleThreadWrapper::EnsureForCurrentThread();
 
   host_connection_.reset(new protocol::ConnectionToHost(true));
   audio_player_.reset(new PepperAudioPlayer(this));
   client_.reset(new ChromotingClient(config, context_.main_task_runner(),
                                      host_connection_.get(), this,
                                      rectangle_decoder_.get(),
                                      audio_player_.get()));
 
@@ skipping 15 matching lines @@
 #endif
   input_handler_.reset(
       new PepperInputHandler(&key_mapper_));
 
   LOG(INFO) << "Connecting to " << config.host_jid
             << ". Local jid: " << config.local_jid << ".";
 
   // Setup the XMPP Proxy.
   xmpp_proxy_ = new PepperXmppProxy(
       base::Bind(&ChromotingInstance::SendOutgoingIq, AsWeakPtr()),
-      plugin_message_loop_, context_.main_task_runner());
+      plugin_task_runner_, context_.main_task_runner());
 
   scoped_ptr<cricket::HttpPortAllocatorBase> port_allocator(
       PepperPortAllocator::Create(this));
   scoped_ptr<protocol::TransportFactory> transport_factory(
       new protocol::LibjingleTransportFactory(port_allocator.Pass(), false));
 
   // Kick off the connection.
   client_->Start(xmpp_proxy_, transport_factory.Pass());
 
   // Start timer that periodically sends perf stats.
-  plugin_message_loop_->PostDelayedTask(
+  plugin_task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&ChromotingInstance::SendPerfStats, AsWeakPtr()),
       base::TimeDelta::FromMilliseconds(kPerfStatsIntervalMs));
 }
 
 void ChromotingInstance::Disconnect() {
-  DCHECK(plugin_message_loop_->BelongsToCurrentThread());
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   // PepperView must be destroyed before the client.
   view_.reset();
 
   LOG(INFO) << "Disconnecting from host.";
   if (client_.get()) {
     // TODO(sergeyu): Should we disconnect asynchronously?
     base::WaitableEvent done_event(true, false);
     client_->Stop(base::Bind(&base::WaitableEvent::Signal,
                              base::Unretained(&done_event)));
@@ skipping 91 matching lines @@
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("iq", iq);
   PostChromotingMessage("sendOutgoingIq", data.Pass());
 }
 
 void ChromotingInstance::SendPerfStats() {
   if (!client_.get()) {
     return;
   }
 
-  plugin_message_loop_->PostDelayedTask(
+  plugin_task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&ChromotingInstance::SendPerfStats, AsWeakPtr()),
       base::TimeDelta::FromMilliseconds(kPerfStatsIntervalMs));
 
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   ChromotingStats* stats = client_->GetStats();
   data->SetDouble("videoBandwidth", stats->video_bandwidth()->Rate());
   data->SetDouble("videoFrameRate", stats->video_frame_rate()->Rate());
   data->SetDouble("captureLatency", stats->video_capture_ms()->Average());
   data->SetDouble("encodeLatency", stats->video_encode_ms()->Average());
   data->SetDouble("decodeLatency", stats->video_decode_ms()->Average());
@@ skipping 17 matching lines @@
 }
 
 void ChromotingInstance::RegisterLoggingInstance() {
   base::AutoLock lock(g_logging_lock.Get());
 
   // Register this instance as the one that will handle all logging calls
   // and display them to the user.
   // If multiple plugins are run, then the last one registered will handle all
   // logging for all instances.
   g_logging_instance.Get() = weak_factory_.GetWeakPtr();
-  g_logging_task_runner.Get() = plugin_message_loop_;
+  g_logging_task_runner.Get() = plugin_task_runner_;
   g_has_logging_instance = true;
 }
 
 void ChromotingInstance::UnregisterLoggingInstance() {
   base::AutoLock lock(g_logging_lock.Get());
 
   // Don't unregister unless we're the currently registered instance.
   if (this != g_logging_instance.Get().get())
     return;
 
@@ skipping 46 matching lines @@
                                 logging_instance, message));
     }
   }
 
   if (g_logging_old_handler)
     return (g_logging_old_handler)(severity, file, line, message_start, str);
   return false;
 }
 
 void ChromotingInstance::ProcessLogToUI(const std::string& message) {
-  DCHECK(plugin_message_loop_->BelongsToCurrentThread());
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   // This flag (which is set only here) is used to prevent LogToUI from posting
   // new tasks while we're in the middle of servicing a LOG call. This can
   // happen if the call to LogDebugInfo tries to LOG anything.
   // Since it is read on the plugin thread, we don't need to lock to set it.
   g_logging_to_plugin = true;
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("message", message);
   PostChromotingMessage("logDebugMessage", data.Pass());
   g_logging_to_plugin = false;
 }
 
 bool ChromotingInstance::IsConnected() {
   return host_connection_.get() &&
     (host_connection_->state() == protocol::ConnectionToHost::CONNECTED);
 }
 
 }  // namespace remoting