[Remoting Android] DisplayUpdaterFactory cleanups

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 60 matching lines @@
   PP_VideoPicture picture_;
 };
 
 PepperVideoRenderer3D::PepperVideoRenderer3D() : callback_factory_(this) {}
 
 PepperVideoRenderer3D::~PepperVideoRenderer3D() {
   if (shader_program_)
     gles2_if_->DeleteProgram(graphics_.pp_resource(), shader_program_);
 }
 
-bool PepperVideoRenderer3D::Initialize(
+void PepperVideoRenderer3D::SetPepperContext(
     pp::Instance* instance,
-    const ClientContext& context,
-    EventHandler* event_handler,
-    protocol::PerformanceTracker* perf_tracker) {
+    EventHandler* event_handler) {
   DCHECK(event_handler);
   DCHECK(!event_handler_);
 
   event_handler_ = event_handler;
+  instance_ = instance;
+}
+
+void PepperVideoRenderer3D::OnViewChanged(const pp::View& 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) {
+  debug_dirty_region_ = enable;
+}
+
+bool PepperVideoRenderer3D::Initialize(
+    const ClientContext& context,
+    protocol::PerformanceTracker* perf_tracker) {
   perf_tracker_ = perf_tracker;
 
   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,
       PP_GRAPHICS3DATTRIB_SAMPLE_BUFFERS, 0,
       PP_GRAPHICS3DATTRIB_WIDTH,          640,
       PP_GRAPHICS3DATTRIB_HEIGHT,         480,
       PP_GRAPHICS3DATTRIB_NONE,
   };
-  graphics_ = pp::Graphics3D(instance, context_attributes);
+  graphics_ = pp::Graphics3D(instance_, context_attributes);
 
   if (graphics_.is_null()) {
     LOG(WARNING) << "Graphics3D interface is not available.";
     return false;
   }
-  if (!instance->BindGraphics(graphics_)) {
+  if (!instance_->BindGraphics(graphics_)) {
     LOG(WARNING) << "Failed to bind Graphics3D.";
     return false;
   }
 
   // Fetch the GLES2 interface to use to render frames.
   gles2_if_ = static_cast<const PPB_OpenGLES2*>(
       pp::Module::Get()->GetBrowserInterface(PPB_OPENGLES2_INTERFACE));
   CHECK(gles2_if_);
 
-  video_decoder_ = pp::VideoDecoder(instance);
+  video_decoder_ = pp::VideoDecoder(instance_);
   if (video_decoder_.is_null()) {
     LOG(WARNING) << "VideoDecoder interface is not available.";
     return false;
   }
 
   PP_Resource graphics_3d = graphics_.pp_resource();
 
   gles2_if_->ClearColor(graphics_3d, 1, 0, 0, 1);
   gles2_if_->Clear(graphics_3d, GL_COLOR_BUFFER_BIT);
 
   // Assign vertex positions and texture coordinates to buffers for use in
   // shader program.
   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);
 
   CheckGLError();
 
   return true;
 }
 
-void PepperVideoRenderer3D::OnViewChanged(const pp::View& 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) {
-  debug_dirty_region_ = enable;
-}
-
 void PepperVideoRenderer3D::OnSessionConfig(
     const protocol::SessionConfig& 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;
@@ skipping 341 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