Remove MediaSource renderer from the remoting client plugin

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>
 
 #if defined(OS_NACL)
@@ skipping 21 matching lines @@
 #include "ppapi/cpp/image_data.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/rect.h"
 #include "ppapi/cpp/var_array_buffer.h"
 #include "ppapi/cpp/var_dictionary.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/util.h"
 #include "remoting/client/chromoting_client.h"
 #include "remoting/client/frame_consumer_proxy.h"
 #include "remoting/client/plugin/delegating_signal_strategy.h"
-#include "remoting/client/plugin/media_source_video_renderer.h"
 #include "remoting/client/plugin/normalizing_input_filter_cros.h"
 #include "remoting/client/plugin/normalizing_input_filter_mac.h"
 #include "remoting/client/plugin/pepper_audio_player.h"
 #include "remoting/client/plugin/pepper_mouse_locker.h"
 #include "remoting/client/plugin/pepper_port_allocator.h"
 #include "remoting/client/plugin/pepper_view.h"
 #include "remoting/client/software_video_renderer.h"
 #include "remoting/client/token_fetcher_proxy.h"
 #include "remoting/protocol/connection_to_host.h"
 #include "remoting/protocol/host_stub.h"
@@ skipping 117 matching lines @@
 base::LazyInstance<base::Lock>::Leaky
     g_logging_lock = LAZY_INSTANCE_INITIALIZER;
 logging::LogMessageHandlerFunction g_logging_old_handler = NULL;
 
 }  // namespace
 
 // String sent in the "hello" message to the webapp to describe features.
 const char ChromotingInstance::kApiFeatures[] =
     "highQualityScaling injectKeyEvent sendClipboardItem remapKey trapKey "
     "notifyClientResolution pauseVideo pauseAudio asyncPin thirdPartyAuth "
-    "pinlessAuth extensionMessage allowMouseLock mediaSourceRendering "
-    "videoControl";
+    "pinlessAuth extensionMessage allowMouseLock videoControl";
 
 const char ChromotingInstance::kRequestedCapabilities[] = "";
 const char ChromotingInstance::kSupportedCapabilities[] = "desktopShape";
 
 ChromotingInstance::ChromotingInstance(PP_Instance pp_instance)
     : pp::Instance(pp_instance),
       initialized_(false),
       plugin_task_runner_(new PluginThreadTaskRunner(&plugin_thread_delegate_)),
       context_(plugin_task_runner_.get()),
       input_tracker_(&mouse_input_filter_),
       key_mapper_(&input_tracker_),
       cursor_setter_(this),
       empty_cursor_filter_(&cursor_setter_),
       text_input_controller_(this),
       use_async_pin_dialog_(false),
-      use_media_source_rendering_(false),
       weak_factory_(this) {
 #if defined(OS_NACL)
   // In NaCl global resources need to be initialized differently because they
   // are not shared with Chrome.
   thread_task_runner_handle_.reset(
       new base::ThreadTaskRunnerHandle(plugin_task_runner_));
   thread_wrapper_.reset(
       new jingle_glue::JingleThreadWrapper(plugin_task_runner_));
   media::InitializeCPUSpecificYUVConversions();
 
@@ skipping 137 matching lines @@
   } else if (method == "onPinFetched") {
     HandleOnPinFetched(*data);
   } else if (method == "onThirdPartyTokenFetched") {
     HandleOnThirdPartyTokenFetched(*data);
   } else if (method == "requestPairing") {
     HandleRequestPairing(*data);
   } else if (method == "extensionMessage") {
     HandleExtensionMessage(*data);
   } else if (method == "allowMouseLock") {
     HandleAllowMouseLockMessage();
-  } else if (method == "enableMediaSourceRendering") {
-    HandleEnableMediaSourceRendering();
   } else if (method == "sendMouseInputWhenUnfocused") {
     HandleSendMouseInputWhenUnfocused();
   } else if (method == "delegateLargeCursors") {
     HandleDelegateLargeCursors();
   }
 }
 
 void ChromotingInstance::DidChangeFocus(bool has_focus) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
@@ skipping 259 matching lines @@
   }
 #elif defined(OS_MACOSX)
   normalizing_input_filter_.reset(new NormalizingInputFilterMac(&key_mapper_));
 #elif defined(OS_CHROMEOS)
   normalizing_input_filter_.reset(new NormalizingInputFilterCros(&key_mapper_));
 #else
   normalizing_input_filter_.reset(new protocol::InputFilter(&key_mapper_));
 #endif
   input_handler_.set_input_stub(normalizing_input_filter_.get());
 
-  if (use_media_source_rendering_) {
-    video_renderer_.reset(new MediaSourceVideoRenderer(this));
-  } else {
-    view_.reset(new PepperView(this, &context_));
-    view_weak_factory_.reset(
-        new base::WeakPtrFactory<FrameConsumer>(view_.get()));
+  view_.reset(new PepperView(this, &context_));
+  view_weak_factory_.reset(
+      new base::WeakPtrFactory<FrameConsumer>(view_.get()));
 
-    // 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 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* renderer =
-        new SoftwareVideoRenderer(context_.main_task_runner(),
-                                  context_.decode_task_runner(),
-                                  consumer_proxy);
-    view_->Initialize(renderer);
-    if (!plugin_view_.is_null())
-      view_->SetView(plugin_view_);
-    video_renderer_.reset(renderer);
-  }
+  SoftwareVideoRenderer* renderer =
+      new SoftwareVideoRenderer(context_.main_task_runner(),
+                                context_.decode_task_runner(),
+                                consumer_proxy);
+  view_->Initialize(renderer);
+  if (!plugin_view_.is_null())
+    view_->SetView(plugin_view_);
+  video_renderer_.reset(renderer);
 
   scoped_ptr<AudioPlayer> audio_player(new PepperAudioPlayer(this));
   client_.reset(new ChromotingClient(&context_, this, video_renderer_.get(),
                                      audio_player.Pass()));
 
   // Connect the input pipeline to the protocol stub & initialize components.
   mouse_input_filter_.set_input_stub(client_->input_stub());
   if (!plugin_view_.is_null()) {
     mouse_input_filter_.set_input_size(webrtc::DesktopSize(
         plugin_view_.GetRect().width(), plugin_view_.GetRect().height()));
@@ skipping 268 matching lines @@
 
 void ChromotingInstance::HandleAllowMouseLockMessage() {
   // Create the mouse lock handler and route cursor shape messages through it.
   mouse_locker_.reset(new PepperMouseLocker(
       this, base::Bind(&PepperInputHandler::set_send_mouse_move_deltas,
                        base::Unretained(&input_handler_)),
       &cursor_setter_));
   empty_cursor_filter_.set_cursor_stub(mouse_locker_.get());
 }
 
-void ChromotingInstance::HandleEnableMediaSourceRendering() {
-  use_media_source_rendering_ = true;
-}
-
 void ChromotingInstance::HandleSendMouseInputWhenUnfocused() {
   input_handler_.set_send_mouse_input_when_unfocused(true);
 }
 
 void ChromotingInstance::HandleDelegateLargeCursors() {
   cursor_setter_.set_delegate_stub(this);
 }
 
 ChromotingStats* ChromotingInstance::GetStats() {
   if (!video_renderer_.get())
@@ skipping 172 matching lines @@
   std::string url_scheme = url.substr(url_components.scheme.begin,
                                       url_components.scheme.len);
   return url_scheme == kChromeExtensionUrlScheme;
 }
 
 bool ChromotingInstance::IsConnected() {
   return client_ &&
          (client_->connection_state() == protocol::ConnectionToHost::CONNECTED);
 }
 
-void ChromotingInstance::OnMediaSourceSize(const webrtc::DesktopSize& size,
-                                           const webrtc::DesktopVector& dpi) {
-  SetDesktopSize(size, dpi);
-}
-
-void ChromotingInstance::OnMediaSourceShape(
-    const webrtc::DesktopRegion& shape) {
-  SetDesktopShape(shape);
-}
-
-void ChromotingInstance::OnMediaSourceReset(const std::string& format) {
-  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
-  data->SetString("format", format);
-  PostLegacyJsonMessage("mediaSourceReset", data.Pass());
-}
-
-void ChromotingInstance::OnMediaSourceData(uint8_t* buffer, size_t buffer_size,
-                                           bool keyframe) {
-  pp::VarArrayBuffer array_buffer(buffer_size);
-  void* data_ptr = array_buffer.Map();
-  memcpy(data_ptr, buffer, buffer_size);
-  array_buffer.Unmap();
-  pp::VarDictionary data_dictionary;
-  data_dictionary.Set(pp::Var("buffer"), array_buffer);
-  data_dictionary.Set(pp::Var("keyframe"), keyframe);
-  PostChromotingMessage("mediaSourceData", data_dictionary);
-}
-
 }  // namespace remoting