Implement video renderer based on VideoDecode API.

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 26 matching lines @@
 #include "remoting/base/constants.h"
 #include "remoting/base/util.h"
 #include "remoting/client/chromoting_client.h"
 #include "remoting/client/plugin/delegating_signal_strategy.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_video_renderer_2d.h"
+#include "remoting/client/plugin/pepper_video_renderer_3d.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"
 #include "remoting/protocol/libjingle_transport_factory.h"
 #include "third_party/webrtc/base/helpers.h"
 #include "third_party/webrtc/base/ssladapter.h"
 #include "url/gurl.h"
 
 // Windows defines 'PostMessage', so we have to undef it.
@@ skipping 185 matching lines @@
   data->SetInteger("apiMinVersion", kApiMinMessagingVersion);
   data->SetString("requestedCapabilities", kRequestedCapabilities);
   data->SetString("supportedCapabilities", kSupportedCapabilities);
 
   PostLegacyJsonMessage("hello", data.Pass());
 }
 
 ChromotingInstance::~ChromotingInstance() {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
+  // Disconnect the client.
+  Disconnect();
+
   // 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();
 
-  client_.reset();
-  video_renderer_.reset();
-
   plugin_task_runner_->Quit();
 
   // Ensure that nothing touches the plugin thread delegate after this point.
   plugin_task_runner_->DetachAndRunShutdownLoop();
 
   // Stopping the context shuts down all chromoting threads.
   context_.Stop();
 }
 
 bool ChromotingInstance::Init(uint32_t argc,
@@ skipping 107 matching lines @@
 
 bool ChromotingInstance::HandleInputEvent(const pp::InputEvent& event) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   if (!IsConnected())
     return false;
 
   return input_handler_.HandleInputEvent(event);
 }
 
+void ChromotingInstance::OnVideoDecodeError() {
+  Disconnect();
+
+  // Assume that the decoder failure was caused by the host not encoding video
+  // correctly and report it as a protocol error.
+  // TODO(sergeyu): Consider using a different error code in case the decoder
+  // error was caused by some other problem.
+  OnConnectionState(protocol::ConnectionToHost::FAILED,
+                    protocol::INCOMPATIBLE_PROTOCOL);
+}
+
 void ChromotingInstance::OnVideoFirstFrameReceived() {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   PostLegacyJsonMessage("onFirstFrameReceived", data.Pass());
 }
 
 void ChromotingInstance::OnVideoSize(const webrtc::DesktopSize& size,
                                         const webrtc::DesktopVector& dpi) {
   mouse_input_filter_.set_output_size(size);
 
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
@@ skipping 221 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());
 
-  video_renderer_.reset(new PepperVideoRenderer2D());
-  bool initialized =
-      video_renderer_->Initialize(this, context_, this);
-  CHECK(initialized);
+  video_renderer_.reset(new PepperVideoRenderer3D());
+  if (!video_renderer_->Initialize(this, context_, this))
+    video_renderer_.reset();

[Wez, 2015/01/06 22:17:10]

nit: This would be cleaner if you replaced the new+Initialize with
FooVideoRenderer::Create() methods.

[Sergey Ulanov, 2015/01/07 19:37:30]

Yes, but given that this is the only place were the renderer needs to be
initialized I don't think that adding the Create() function is worth it.

[Wez, 2015/01/07 20:55:01]

Acknowledged.

+
+  // If we failed to initialize 3D renderer (because there is no hardware
+  // support on this machine) then use the 2D renderer.
+  if (!video_renderer_) {
+    LOG(WARNING)
+        << "Failed to initialize 3D renderer. Using 2D renderer instead.";
+    video_renderer_.reset(new PepperVideoRenderer2D());
+    if (!video_renderer_->Initialize(this, context_, this))
+      video_renderer_.reset();
+  }
+
+  CHECK(video_renderer_);
 
   if (!plugin_view_.is_null())
     video_renderer_->OnViewChanged(plugin_view_);
 
   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());
@@ skipping 32 matching lines @@
 
   // Start timer that periodically sends perf stats.
   plugin_task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&ChromotingInstance::SendPerfStats,
                             weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kPerfStatsIntervalMs));
 }
 
 void ChromotingInstance::HandleDisconnect(const base::DictionaryValue& data) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
-
-  VLOG(0) << "Disconnecting from host.";
-
-  // Disconnect the input pipeline and teardown the connection.
-  mouse_input_filter_.set_input_stub(NULL);
-  client_.reset();
-  video_renderer_.reset();
+  Disconnect();
 }
 
 void ChromotingInstance::HandleOnIncomingIq(const base::DictionaryValue& data) {
   std::string iq;
   if (!data.GetString("iq", &iq)) {
     LOG(ERROR) << "Invalid incomingIq() data.";
     return;
   }
 
   // Just ignore the message if it's received before Connect() is called. It's
@@ skipping 217 matching lines @@
 }
 
 void ChromotingInstance::HandleSendMouseInputWhenUnfocused() {
   input_handler_.set_send_mouse_input_when_unfocused(true);
 }
 
 void ChromotingInstance::HandleDelegateLargeCursors() {
   cursor_setter_.set_delegate_stub(this);
 }
 
+void ChromotingInstance::Disconnect() {
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
+
+  VLOG(0) << "Disconnecting from host.";
+
+  // Disconnect the input pipeline and teardown the connection.
+  mouse_input_filter_.set_input_stub(NULL);
+  client_.reset();
+  video_renderer_.reset();
+}
+
 void ChromotingInstance::PostChromotingMessage(const std::string& method,
                                                const pp::VarDictionary& data) {
   pp::VarDictionary message;
   message.Set(pp::Var("method"), pp::Var(method));
   message.Set(pp::Var("data"), data);
   PostMessage(message);
 }
 
 void ChromotingInstance::PostLegacyJsonMessage(
     const std::string& method,
@@ skipping 159 matching lines @@
                                       url_components.scheme.len);
   return url_scheme == kChromeExtensionUrlScheme;
 }
 
 bool ChromotingInstance::IsConnected() {
   return client_ &&
          (client_->connection_state() == protocol::ConnectionToHost::CONNECTED);
 }
 
 }  // namespace remoting