[Chromoting] Fallback to use software renderer if desktop image size is larger than GPU limitaiton

remoting/client/plugin/pepper_video_renderer_3d.cc

Index: remoting/client/plugin/pepper_video_renderer_3d.cc
diff --git a/remoting/client/plugin/pepper_video_renderer_3d.cc b/remoting/client/plugin/pepper_video_renderer_3d.cc
index b60f9bd72bb9e99d3745093ef73a7b674226b289..675fff673afe5b509ec3ea055dcd1bf9f4828fe5 100644
--- a/remoting/client/plugin/pepper_video_renderer_3d.cc
+++ b/remoting/client/plugin/pepper_video_renderer_3d.cc
@@ -10,7 +10,6 @@
 #include <utility>
 
 #include "ppapi/c/pp_codecs.h"
-#include "ppapi/c/ppb_opengles2.h"
 #include "ppapi/c/ppb_video_decoder.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/lib/gl/include/GLES2/gl2.h"
@@ -91,11 +90,15 @@ void PepperVideoRenderer3D::SetPepperContext(
   DCHECK(event_handler);
   DCHECK(!event_handler_);
 
+  fallback_renderer_.SetPepperContext(instance, event_handler);
+
   event_handler_ = event_handler;
   pp_instance_ = instance;
 }
 
 void PepperVideoRenderer3D::OnViewChanged(const pp::View& view) {
+  fallback_renderer_.OnViewChanged(view);
+
   pp::Size size = view.GetRect().size();
   float scale = view.GetDeviceScale();
   view_size_.set(ceilf(size.width() * scale), ceilf(size.height() * scale));
@@ -106,12 +109,16 @@ void PepperVideoRenderer3D::OnViewChanged(const pp::View& view) {
 }
 
 void PepperVideoRenderer3D::EnableDebugDirtyRegion(bool enable) {
+  fallback_renderer_.EnableDebugDirtyRegion(enable);
   debug_dirty_region_ = enable;
 }
 
 bool PepperVideoRenderer3D::Initialize(
     const ClientContext& context,
     protocol::FrameStatsConsumer* stats_consumer) {
+  fallback_renderer_usable_ =
+      fallback_renderer_.Initialize(context, stats_consumer);
+
   stats_consumer_ = stats_consumer;
 
   const int32_t context_attributes[] = {
@@ -166,6 +173,8 @@ bool PepperVideoRenderer3D::Initialize(
   gles2_if_->BindBuffer(graphics_3d, GL_ARRAY_BUFFER, buffer);
   gles2_if_->BufferData(graphics_3d, GL_ARRAY_BUFFER, sizeof(kVertices),
                         kVertices, GL_STATIC_DRAW);
+  gles2_if_->GetIntegerv(
+      graphics_3d, GL_MAX_TEXTURE_SIZE, &gl_max_texture_size_);
 
   CheckGLError();
 
@@ -174,6 +183,8 @@ bool PepperVideoRenderer3D::Initialize(
 
 void PepperVideoRenderer3D::OnSessionConfig(
     const protocol::SessionConfig& config) {
+  fallback_renderer_.OnSessionConfig(config);
+
   PP_VideoProfile video_profile = PP_VIDEOPROFILE_VP8_ANY;
   switch (config.video_config().codec) {
     case protocol::ChannelConfig::CODEC_VP8:
@@ -212,6 +223,18 @@ protocol::FrameStatsConsumer* PepperVideoRenderer3D::GetFrameStatsConsumer() {
 void PepperVideoRenderer3D::ProcessVideoPacket(
     std::unique_ptr<VideoPacket> packet,
     const base::Closure& done) {
+  if (!use_fallback_renderer_ && fallback_renderer_usable_) {
+    use_fallback_renderer_ =

[Sergey Ulanov, 2016/07/14 17:45:28]

Once we start using the fallback renderer I think we want to keep using it.
Switching back and forth between them when resolution changes may not be safe.

Also I think we need to free all old pending frames and all resources used by
the 3D renderer before the fallback happens. Freeing all FrameTracker objects is
especially important as they will call Done callback.

  current_picture_frames_.clear();
  current_picture_.reset()
  next_picture_frames_.clear();
  next_picture_.reset();
  decoded_frames_.clear();
  pending_frames_.clear();

  // Reset Pepper resources, freeing the old ones.
  graphics_ = pp::Graphics3D();  
  video_renderer_ = pp::VideoDecoder();

[Hzj_jie, 2016/07/15 02:30:50]

No, if use_fallback_renderer_ is true, it won't fallback.
Others are added.

+        gl_max_texture_size_ < packet->format().screen_width() ||

[Sergey Ulanov, 2016/07/14 17:45:28]

nit: would be more readable if this condition was in the opposite order:
 packet->format().screen_width() >  gl_max_texture_size_

[Sergey Ulanov, 2016/07/14 17:45:28]

screen_width() and screen_height() are set only when size changes. Code below
uses .has_screen_width()

[Hzj_jie, 2016/07/15 02:30:50]

I believe in protobuf, an unset integer field is always zero. And
gl_max_texture_size_ won't be less than zero.

[Hzj_jie, 2016/07/15 02:30:50]

Done.

[Sergey Ulanov, 2016/07/15 23:33:18]

It's true, but in general it's usually better to check pretense of the fields
explicitly, if only to make it clear in the code that this case was considered.
In this particular case it makes difference when only one of the two fields is
set: that's incorrect packet and we don't want to initiate fallback in that
scenario.

[Hzj_jie, 2016/07/16 01:19:21]

Done.

+        gl_max_texture_size_ < packet->format().screen_height();
+  }
+
+  if (use_fallback_renderer_) {
+    fallback_renderer_.GetVideoStub()->ProcessVideoPacket(
+        std::move(packet), done);
+    return;
+  }
+
   VideoPacket* packet_ptr = packet.get();
   std::unique_ptr<FrameTracker> frame_tracker(
       new FrameTracker(std::move(packet), stats_consumer_, done));