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

remoting/client/plugin/pepper_video_renderer_3d.cc

 // Copyright 2014 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/pepper_video_renderer_3d.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 73 matching lines @@
   if (shader_program_)
     gles2_if_->DeleteProgram(graphics_.pp_resource(), shader_program_);
 }
 
 void PepperVideoRenderer3D::SetPepperContext(
     pp::Instance* instance,
     EventHandler* event_handler) {
   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));
   graphics_.ResizeBuffers(view_size_.width(), view_size_.height());
 
   force_repaint_ = true;
   PaintIfNeeded();
 }
 
 void PepperVideoRenderer3D::EnableDebugDirtyRegion(bool enable) {
+  fallback_renderer_.EnableDebugDirtyRegion(enable);
   debug_dirty_region_ = enable;
 }
 
 bool PepperVideoRenderer3D::Initialize(
     const ClientContext& context,
     protocol::FrameStatsConsumer* stats_consumer) {
+  bool fallback_renderer_initialize_result =
+      fallback_renderer_.Initialize(context, stats_consumer);
+  DCHECK(fallback_renderer_initialize_result);
+
   stats_consumer_ = stats_consumer;
 
   const int32_t context_attributes[] = {
       PP_GRAPHICS3DATTRIB_ALPHA_SIZE,     8,
       PP_GRAPHICS3DATTRIB_BLUE_SIZE,      8,
       PP_GRAPHICS3DATTRIB_GREEN_SIZE,     8,
       PP_GRAPHICS3DATTRIB_RED_SIZE,       8,
       PP_GRAPHICS3DATTRIB_DEPTH_SIZE,     0,
       PP_GRAPHICS3DATTRIB_STENCIL_SIZE,   0,
       PP_GRAPHICS3DATTRIB_SAMPLES,        0,
@@ skipping 34 matching lines @@
   static const float kVertices[] = {
       -1, -1, -1, 1, 1, -1, 1, 1,  // Position coordinates.
       0,  1,  0,  0, 1, 1,  1, 0,  // Texture coordinates.
   };
 
   GLuint buffer;
   gles2_if_->GenBuffers(graphics_3d, 1, &buffer);
   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();
 
   return true;
 }
 
 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:
       video_profile = PP_VIDEOPROFILE_VP8_ANY;
       break;
     case protocol::ChannelConfig::CODEC_VP9:
       video_profile = PP_VIDEOPROFILE_VP9_ANY;
       break;
     default:
       NOTREACHED();
@@ skipping 18 matching lines @@
   return nullptr;
 }
 
 protocol::FrameStatsConsumer* PepperVideoRenderer3D::GetFrameStatsConsumer() {
   return stats_consumer_;
 }
 
 void PepperVideoRenderer3D::ProcessVideoPacket(
     std::unique_ptr<VideoPacket> packet,
     const base::Closure& done) {
+  if (!use_fallback_renderer_) {
+    use_fallback_renderer_ =
+        packet->format().screen_width() > gl_max_texture_size_ ||
+        packet->format().screen_height() > gl_max_texture_size_;

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

AFAICT, this check won't work for debug build.
gles2_if_->GetIntegerv(GL_MAX_TEXTURE_SIZE) returns a different value for debug
build. No idea whether this is an expected behavior.

[Sergey Ulanov, 2016/07/15 23:39:56]

This is concerning. Is it in debug builds of the webapp or debug builds of
chrome?
What does glGetIntegerv(GL_MAX_TEXTURE_SIZE) return in debug builds?
(you can use LOG(ERROR) in the plugin - it goes to JS console)

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

Sorry, I have made a wrong assumption. Actually we cannot get correct
VideoPacketFormat in debug build, the screen_width() and screen_height() are
always zero or unset. Since this is a separated issue, I will prepare another
change to fix.

+    if (use_fallback_renderer_) {
+      // Clear current instance and use fallback_renderer_.
+      current_picture_frames_.clear();
+      current_picture_.reset();
+      next_picture_frames_.clear();
+      next_picture_.reset();
+      decoded_frames_.clear();
+      pending_frames_.clear();
+      graphics_ = pp::Graphics3D();
+      video_decoder_ = pp::VideoDecoder();
+    }
+  }
+
+  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));
 
   // Don't need to do anything if the packet is empty. Host sends empty video
   // packets when the screen is not changing.
   if (packet_ptr->data().empty())
     return;
 
   if (!frame_received_) {
@@ skipping 305 matching lines @@
   gles2_if_->AttachShader(graphics_.pp_resource(), shader_program_, shader);
   gles2_if_->DeleteShader(graphics_.pp_resource(), shader);
 }
 
 void PepperVideoRenderer3D::CheckGLError() {
   GLenum error = gles2_if_->GetError(graphics_.pp_resource());
   CHECK_EQ(error, static_cast<GLenum>(GL_NO_ERROR)) << "GL error: " << error;
 }
 
 }  // namespace remoting