Add workaround for PPB_VideoDecoder not setting visible_rect.

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 "base/callback_helpers.h"
 #include "base/stl_util.h"
 #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"
 #include "ppapi/lib/gl/include/GLES2/gl2ext.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/performance_tracker.h"
 #include "remoting/protocol/session_config.h"
 
 namespace remoting {
 
 // The implementation here requires that the decoder allocates at least 3
-// pictures. PPB_VideoDecode didn't support this parameter prior to
+// pictures. PPB_VideoDecoder didn't support this parameter prior to
 // 1.1, so we have to pass 0 for backwards compatibility with older versions of
 // the browser. Currently all API implementations allocate more than 3 buffers
 // by default.
 //
-// TODO(sergeyu): Change this to 3 once PPB_VideoDecode v1.1 is enabled on
+// TODO(sergeyu): Change this to 3 once PPB_VideoDecoder v1.1 is enabled on
 // stable channel.

[Wez, 2015/10/19 21:56:16]

nit: Is there a bug filed for that work? If so, reference it here?

[Sergey Ulanov, 2015/10/19 22:19:51]

Added reference to the bug to get 1.1 API enabled on stable.

 const uint32_t kMinimumPictureCount = 0;  // 3
 
 class PepperVideoRenderer3D::PendingPacket {
  public:
   PendingPacket(scoped_ptr<VideoPacket> packet, const base::Closure& done)
       : packet_(packet.Pass()),
         done_runner_(done) {
   }
 
   ~PendingPacket() {}
@@ skipping 197 matching lines @@
     webrtc::DesktopRegion dirty_region;
     for (int i = 0; i < packet->dirty_rects_size(); ++i) {
       Rect remoting_rect = packet->dirty_rects(i);
       dirty_region.AddRect(webrtc::DesktopRect::MakeXYWH(
           remoting_rect.x(), remoting_rect.y(),
           remoting_rect.width(), remoting_rect.height()));
     }
     event_handler_->OnVideoFrameDirtyRegion(dirty_region);
   }
 
+  if (frame_sizes_) {
+    frame_sizes_->insert(std::make_pair(packet->frame_id(), frame_size_));
+  }
+
   pending_packets_.push_back(
       new PendingPacket(packet.Pass(), done_runner.Release()));
   DecodeNextPacket();
 }
 
 void PepperVideoRenderer3D::OnInitialized(int32_t result) {
   // Assume that VP8 and VP9 codecs are always supported by the browser.
   CHECK_EQ(result, PP_OK) << "VideoDecoder::Initialize() failed: " << result;
   initialization_finished_ = true;
 
@@ skipping 48 matching lines @@
   get_picture_pending_ = false;
 
   if (result != PP_OK) {
     LOG(ERROR) << "VideoDecoder::GetPicture() returned " << result;
     event_handler_->OnVideoDecodeError();
     return;
   }
 
   perf_tracker_->OnFrameDecoded(picture.decode_id);
 
+  // Workaround crbug.com/542945 by filling in visible_rect if it isn't set.
+  if (picture.visible_rect.size.width == 0 ||
+      picture.visible_rect.size.height == 0 || frame_sizes_) {
+
+    // Enable workaround by creating |frame_sizes_|.
+    if (!frame_sizes_) {
+      LOG(WARNING) << "PPB_VideoDecoder doesn't set visible_rect.";
+      frame_sizes_.reset(new FrameSizesMap());
+    }
+
+    FrameSizesMap::iterator size_it = frame_sizes_->find(picture.decode_id);
+    if (size_it != frame_sizes_->end()) {
+      picture.visible_rect.size.width = size_it->second.width();
+      picture.visible_rect.size.height = size_it->second.height();
+      frame_sizes_->erase(size_it);
+    } else {
+      // For the first few frames |frames_sizes_| will be empty as
+      // |frame_sizes_| is created only after the first picture is received and
+      // it's known that the workaround is necessary. So here we use
+      // |texture_size| as frame size. This may result is some minor visual
+      // artifacts, which will disappear with the next frame processed by
+      // ProcessVideoPacket().
+      picture.visible_rect.size.width = picture.texture_size.width;
+      picture.visible_rect.size.height = picture.texture_size.width;
+    }
+  }
+
   next_picture_.reset(new Picture(&video_decoder_, picture));
 
   PaintIfNeeded();
   GetNextPicture();
 }
 
 void PepperVideoRenderer3D::PaintIfNeeded() {
   bool need_repaint = next_picture_ || (force_repaint_ && current_picture_);
   if (paint_pending_ || !need_repaint)
     return;
 
   if (next_picture_)
     current_picture_ = next_picture_.Pass();
 
   force_repaint_ = false;
 
   const PP_VideoPicture& picture = current_picture_->picture();
   PP_Resource graphics_3d = graphics_.pp_resource();
 
   EnsureProgramForTexture(picture.texture_target);
 
   gles2_if_->UseProgram(graphics_3d, shader_program_);
 
   // Calculate v_scale passed to the vertex shader.
   double scale_x = picture.visible_rect.size.width;
   double scale_y = picture.visible_rect.size.height;
   if (picture.texture_target != GL_TEXTURE_RECTANGLE_ARB) {
+    CHECK(picture.texture_size.width > 0 && picture.texture_size.height > 0);

[Sergey Ulanov, 2015/10/19 21:47:20]

These CHECKs will help to diagnose similar issues in the future.

     scale_x /= picture.texture_size.width;
     scale_y /= picture.texture_size.height;
   }
   gles2_if_->Uniform2f(graphics_3d, shader_texcoord_scale_location_,
                        scale_x, scale_y);
 
   // Set viewport position & dimensions.
   gles2_if_->Viewport(graphics_3d, 0, 0, view_size_.width(),
                       view_size_.height());
 
   // Select the texture unit GL_TEXTURE0.
   gles2_if_->ActiveTexture(graphics_3d, GL_TEXTURE0);
 
   // Select the texture.
   gles2_if_->BindTexture(graphics_3d, picture.texture_target,
                          picture.texture_id);
 
   // Select linear filter in case the texture needs to be scaled.
   gles2_if_->TexParameteri(graphics_3d, picture.texture_target,
                            GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 
   // When view dimensions are a multiple of the frame size then use
   // nearest-neighbor scaling to achieve crisper image. Linear filter is used in
   // all other cases.
   GLint mag_filter = GL_LINEAR;
+  CHECK(picture.visible_rect.size.width > 0 &&
+        picture.visible_rect.size.height > 0);
   if (view_size_.width() % picture.visible_rect.size.width == 0 &&
       view_size_.height() % picture.visible_rect.size.height == 0) {
     mag_filter = GL_NEAREST;
   }
   gles2_if_->TexParameteri(graphics_3d, picture.texture_target,
                            GL_TEXTURE_MAG_FILTER, mag_filter);
 
   // Render texture by drawing a triangle strip with 4 vertices.
   gles2_if_->DrawArrays(graphics_3d, GL_TRIANGLE_STRIP, 0, 4);
 
@@ skipping 121 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