Add VideoProcessor interface.

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 <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 21 matching lines @@
 #include "remoting/base/util.h"
 #include "remoting/client/chromoting_client.h"
 #include "remoting/client/client_config.h"
 #include "remoting/client/frame_consumer_proxy.h"
 #include "remoting/client/plugin/delegating_signal_strategy.h"
 #include "remoting/client/plugin/pepper_audio_player.h"
 #include "remoting/client/plugin/pepper_input_handler.h"
 #include "remoting/client/plugin/pepper_port_allocator.h"
 #include "remoting/client/plugin/pepper_token_fetcher.h"
 #include "remoting/client/plugin/pepper_view.h"
-#include "remoting/client/rectangle_update_decoder.h"
+#include "remoting/client/software_video_renderer.h"
 #include "remoting/protocol/connection_to_host.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/libjingle_transport_factory.h"
 #include "third_party/libjingle/source/talk/base/helpers.h"
 #include "url/gurl.h"
 
 // Windows defines 'PostMessage', so we have to undef it.
 #if defined(PostMessage)
 #undef PostMessage
 #endif
@@ skipping 574 matching lines @@
                                            const std::string& local_jid) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
 
 
   view_.reset(new PepperView(this, &context_));
   view_weak_factory_.reset(
       new base::WeakPtrFactory<FrameConsumer>(view_.get()));
 
-  // RectangleUpdateDecoder runs on a separate thread so for now we wrap
+  // SoftwareVideoRenderer 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_task_runner_,
                              view_weak_factory_->GetWeakPtr());
 
+  SoftwareVideoRenderer* decoder =
+      new SoftwareVideoRenderer(context_.main_task_runner(),
+                                context_.decode_task_runner(),
+                                consumer_proxy);
+  view_->Initialize(decoder);
+  video_renderer_.reset(decoder);
+
   host_connection_.reset(new protocol::ConnectionToHost(true));
   scoped_ptr<AudioPlayer> audio_player(new PepperAudioPlayer(this));
-  client_.reset(new ChromotingClient(config, &context_,
-                                     host_connection_.get(), this,
-                                     consumer_proxy, audio_player.Pass()));
+  client_.reset(new ChromotingClient(config, &context_, host_connection_.get(),
+                                     this, video_renderer_.get(),
+                                     audio_player.Pass()));
 
-  view_->Initialize(client_->GetFrameProducer());
-
-  if (!plugin_view_.is_null()) {
+  if (!plugin_view_.is_null())
     view_->SetView(plugin_view_);
-  }
 
   // Connect the input pipeline to the protocol stub & initialize components.
   mouse_input_filter_.set_input_stub(host_connection_->input_stub());
   mouse_input_filter_.set_input_size(view_->get_view_size_dips());
 
   VLOG(0) << "Connecting to " << config.host_jid
           << ". Local jid: " << local_jid << ".";
 
   // Setup the signal strategy.
   signal_strategy_.reset(new DelegatingSignalStrategy(
@@ skipping 235 matching lines @@
   message.set_type(type);
   message.set_data(message_data);
   host_connection_->host_stub()->DeliverClientMessage(message);
 }
 
 void ChromotingInstance::HandleAllowMouseLockMessage() {
   input_handler_.AllowMouseLock();
 }
 
 ChromotingStats* ChromotingInstance::GetStats() {
-  if (!client_.get())
+  if (!video_renderer_.get())
     return NULL;
-  return client_->GetStats();
+  return video_renderer_->GetStats();
 }
 
 void ChromotingInstance::PostChromotingMessage(
     const std::string& method,
     scoped_ptr<base::DictionaryValue> data) {
   scoped_ptr<base::DictionaryValue> message(new base::DictionaryValue());
   message->SetString("method", method);
   message->Set("data", data.release());
 
   std::string message_json;
   base::JSONWriter::Write(message.get(), &message_json);
   PostMessage(pp::Var(message_json));
 }
 
 void ChromotingInstance::SendTrappedKey(uint32 usb_keycode, bool pressed) {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetInteger("usbKeycode", usb_keycode);
   data->SetBoolean("pressed", pressed);
   PostChromotingMessage("trappedKeyEvent", data.Pass());
 }
 
 void ChromotingInstance::SendOutgoingIq(const std::string& iq) {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("iq", iq);
   PostChromotingMessage("sendOutgoingIq", data.Pass());
 }
 
 void ChromotingInstance::SendPerfStats() {
-  if (!client_.get()) {
+  if (!video_renderer_.get()) {
     return;
   }
 
   plugin_task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&ChromotingInstance::SendPerfStats,
                             weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kPerfStatsIntervalMs));
 
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
-  ChromotingStats* stats = client_->GetStats();
+  ChromotingStats* stats = video_renderer_->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());
   data->SetDouble("renderLatency", stats->video_paint_ms()->Average());
   data->SetDouble("roundtripLatency", stats->round_trip_ms()->Average());
   PostChromotingMessage("onPerfStats", data.Pass());
 }
 
@@ skipping 114 matching lines @@
                                       url_components.scheme.len);
   return url_scheme == kChromeExtensionUrlScheme;
 }
 
 bool ChromotingInstance::IsConnected() {
   return host_connection_.get() &&
     (host_connection_->state() == protocol::ConnectionToHost::CONNECTED);
 }
 
 }  // namespace remoting