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
-// stable channel.
+// TODO(sergeyu): Change this to 3 once PPB_VideoDecoder v1.1 is enabled on
+// stable channel (crbug.com/520323).
 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 265 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) {
+    static bool warning_logged = false;
+    if (!warning_logged) {
+      LOG(WARNING) << "PPB_VideoDecoder doesn't set visible_rect.";

[Wez, 2015/10/20 04:57:44]

What's the point of logging a warning in this case?

[Sergey Ulanov, 2015/10/20 14:37:52]

To make it easy to verify if the problem is still there.

[Wez, 2015/10/20 17:16:50]

You mean easy to see whether the PPAPI has been fixed? Gotcha.

+      warning_logged = true;
+    }
+
+    picture.visible_rect.size.width =
+        std::min(frame_size_.width(), picture.texture_size.width);
+    picture.visible_rect.size.height =
+        std::min(frame_size_.height(), picture.texture_size.height);
+  }
+
   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);
     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