Part 1/3 (compositor) of adding with device scale factor to transport surfaces

cc/output/gl_renderer_unittest.cc

 // Copyright 2012 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 "cc/output/gl_renderer.h"
 
 #include <set>
 
 #include "cc/base/math_util.h"
 #include "cc/output/compositor_frame_metadata.h"
@@ skipping 133 matching lines @@
 };
 
 class FakeRendererClient : public RendererClient {
  public:
   FakeRendererClient()
       : host_impl_(&proxy_),
         set_full_root_layer_damage_count_(0),
         last_call_was_set_visibility_(0),
         root_layer_(LayerImpl::Create(host_impl_.active_tree(), 1)),
         memory_allocation_limit_bytes_(
-            PrioritizedResourceManager::DefaultMemoryAllocationLimit()) {
+            PrioritizedResourceManager::DefaultMemoryAllocationLimit()),
+        viewport_size_(gfx::Size(1, 1)),
+        scale_factor_(1.f),
+        is_viewport_changed_(true) {
     root_layer_->CreateRenderSurface();
     RenderPass::Id render_pass_id =
         root_layer_->render_surface()->RenderPassId();
     scoped_ptr<RenderPass> root_render_pass = RenderPass::Create();
     root_render_pass->SetNew(
         render_pass_id, gfx::Rect(), gfx::Rect(), gfx::Transform());
     render_passes_in_draw_order_.push_back(root_render_pass.Pass());
   }
 
   // RendererClient methods.
   virtual gfx::Size DeviceViewportSize() const OVERRIDE {
     static gfx::Size fake_size(1, 1);
     return fake_size;
   }
+  virtual float DeviceScaleFactor() const OVERRIDE {
+    return scale_factor_;
+  }
   virtual const LayerTreeSettings& Settings() const OVERRIDE {
     static LayerTreeSettings fake_settings;
     return fake_settings;
   }
   virtual void SetFullRootLayerDamage() OVERRIDE {
     set_full_root_layer_damage_count_++;
   }
   virtual void SetManagedMemoryPolicy(const ManagedMemoryPolicy& policy)
       OVERRIDE {
     memory_allocation_limit_bytes_ = policy.bytes_limit_when_visible;
@@ skipping 13 matching lines @@
   }
 
   // Methods added for test.
   int set_full_root_layer_damage_count() const {
     return set_full_root_layer_damage_count_;
   }
   void set_last_call_was_set_visibility_pointer(
       bool* last_call_was_set_visibility) {
     last_call_was_set_visibility_ = last_call_was_set_visibility;
   }
+  void set_viewport_and_scale(
+      gfx::Size viewport_size, float scale_factor) {
+    viewport_size_ = viewport_size;
+    scale_factor_ = scale_factor;
+    is_viewport_changed_ = true;
+  }
+  bool is_viewport_changed() const { return is_viewport_changed_; }
+  void clear_viewport_changed() { is_viewport_changed_ = false; }
 
   RenderPass* root_render_pass() { return render_passes_in_draw_order_.back(); }
   RenderPassList* render_passes_in_draw_order() {
     return &render_passes_in_draw_order_;
   }
 
   size_t memory_allocation_limit_bytes() const {
     return memory_allocation_limit_bytes_;
   }
 
  private:
   FakeImplProxy proxy_;
   FakeLayerTreeHostImpl host_impl_;
   int set_full_root_layer_damage_count_;
   bool* last_call_was_set_visibility_;
   scoped_ptr<LayerImpl> root_layer_;
   RenderPassList render_passes_in_draw_order_;
   size_t memory_allocation_limit_bytes_;
+  gfx::Size viewport_size_;
+  float scale_factor_;
+  bool is_viewport_changed_;
 };
 
 class FakeRendererGL : public GLRenderer {
  public:
   FakeRendererGL(RendererClient* client,
                  OutputSurface* output_surface,
                  ResourceProvider* resource_provider)
       : GLRenderer(client, output_surface, resource_provider, 0) {}
 
   // GLRenderer methods.
@@ skipping 1200 matching lines @@
 class OutputSurfaceMockContext : public TestWebGraphicsContext3D {
  public:
   // Specifically override methods even if they are unused (used in conjunction
   // with StrictMock). We need to make sure that GLRenderer does not issue
   // framebuffer-related GL calls directly. Instead these are supposed to go
   // through the OutputSurface abstraction.
   MOCK_METHOD0(ensureBackbufferCHROMIUM, void());
   MOCK_METHOD0(discardBackbufferCHROMIUM, void());
   MOCK_METHOD2(bindFramebuffer, void(WGC3Denum target, WebGLId framebuffer));
   MOCK_METHOD0(prepareTexture, void());
-  MOCK_METHOD2(reshape, void(int width, int height));
+  MOCK_METHOD3(reshapeWithScaleFactor,
+               void(int width, int height, float scale_factor));
   MOCK_METHOD4(drawElements,
                void(WGC3Denum mode,
                     WGC3Dsizei count,
                     WGC3Denum type,
                     WGC3Dintptr offset));
 
   virtual WebString getString(WebKit::WGC3Denum name) {
     if (name == GL_EXTENSIONS)
       return WebString(
           "GL_CHROMIUM_post_sub_buffer GL_CHROMIUM_discard_backbuffer");
     return WebString();
   }
 };
 
 class MockOutputSurface : public OutputSurface {
  public:
   MockOutputSurface()
       : OutputSurface(scoped_ptr<WebKit::WebGraphicsContext3D>(
             new StrictMock<OutputSurfaceMockContext>)) {}
   virtual ~MockOutputSurface() {}
 
   MOCK_METHOD1(SendFrameToParentCompositor, void(CompositorFrame* frame));
   MOCK_METHOD0(EnsureBackbuffer, void());
   MOCK_METHOD0(DiscardBackbuffer, void());
-  MOCK_METHOD1(Reshape, void(gfx::Size size));
+  MOCK_METHOD2(Reshape, void(gfx::Size size, float scale_factor));
   MOCK_METHOD0(BindFramebuffer, void());
   MOCK_METHOD2(PostSubBuffer, void(gfx::Rect rect, const LatencyInfo&));
   MOCK_METHOD1(SwapBuffers, void(const LatencyInfo&));
 };
 
 class MockOutputSurfaceTest : public testing::Test, public FakeRendererClient {
  protected:
   MockOutputSurfaceTest()
       : resource_provider_(ResourceProvider::Create(&output_surface_, 0)),
         renderer_(this, &output_surface_, resource_provider_.get()) {}
 
   virtual void SetUp() { EXPECT_TRUE(renderer_.Initialize()); }
 
   void SwapBuffers() { renderer_.SwapBuffers(LatencyInfo()); }
 
   void DrawFrame() {
     gfx::Rect viewport_rect(DeviceViewportSize());
     ScopedPtrVector<RenderPass>* render_passes = render_passes_in_draw_order();
     render_passes->clear();
 
     RenderPass::Id render_pass_id(1, 0);
     TestRenderPass* render_pass = AddRenderPass(
         render_passes, render_pass_id, viewport_rect, gfx::Transform());
     AddQuad(render_pass, viewport_rect, SK_ColorGREEN);
 
     EXPECT_CALL(output_surface_, EnsureBackbuffer()).WillRepeatedly(Return());
 
-    EXPECT_CALL(output_surface_, Reshape(_)).Times(1);
+    if (is_viewport_changed()) {
+      EXPECT_CALL(output_surface_,
+                  Reshape(DeviceViewportSize(), DeviceScaleFactor())).Times(1);
+        clear_viewport_changed();

[danakj, 2013/05/22 18:39:16]

nit: 4space indent

[ccameron, 2013/05/22 19:24:43]

Done.

+    }
 
     EXPECT_CALL(output_surface_, BindFramebuffer()).Times(1);
 
     EXPECT_CALL(*Context(), drawElements(_, _, _, _)).Times(1);
 
     renderer_.DecideRenderPassAllocationsForFrame(
         *render_passes_in_draw_order());
     renderer_.DrawFrame(render_passes_in_draw_order());
   }
 
   OutputSurfaceMockContext* Context() {
     return static_cast<OutputSurfaceMockContext*>(output_surface_.context3d());
   }
 
   StrictMock<MockOutputSurface> output_surface_;
   scoped_ptr<ResourceProvider> resource_provider_;
   FakeRendererGL renderer_;
 };
 
 TEST_F(MockOutputSurfaceTest, DrawFrameAndSwap) {
   DrawFrame();
 
   EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);
   renderer_.SwapBuffers(LatencyInfo());
 }
 
+TEST_F(MockOutputSurfaceTest, DrawFrameAndResizeAndSwap) {
+  DrawFrame();
+  EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);
+  renderer_.SwapBuffers(LatencyInfo());
+
+  set_viewport_and_scale(gfx::Size(2, 2), 2.f);
+  renderer_.ViewportChanged();

[Ken Russell (switch to Gerrit), 2013/05/22 18:50:54]

Is there any way to check that these result in a particular call or calls?

[ccameron, 2013/05/22 19:24:43]

ViewportChanged() indicates that the RendererClient's values have changed and
need to be re-examined  -- if the call is removed then the EXPECT_CALL(Reshape)
fails.

From an architectural perspective, this approach is probably less robust than
having the renderer always check the values and elide redundant calls itself.

+
+  DrawFrame();
+  EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);
+  renderer_.SwapBuffers(LatencyInfo());
+
+  DrawFrame();
+  EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);
+  renderer_.SwapBuffers(LatencyInfo());
+
+  set_viewport_and_scale(gfx::Size(1, 1), 1.f);
+  renderer_.ViewportChanged();
+
+  DrawFrame();
+  EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);
+  renderer_.SwapBuffers(LatencyInfo());
+}
+
 class MockOutputSurfaceTestWithPartialSwap : public MockOutputSurfaceTest {
  public:
   virtual const LayerTreeSettings& Settings() const OVERRIDE {
     static LayerTreeSettings fake_settings;
     fake_settings.partial_swap_enabled = true;
     return fake_settings;
   }
 };
 
 TEST_F(MockOutputSurfaceTestWithPartialSwap, DrawFrameAndSwap) {
@@ skipping 83 matching lines @@
   base::MessageLoop::current()->Run();
 
   // The sync point should have happened.
   EXPECT_EQ(1, sync_point_callback_count);
   EXPECT_EQ(1, other_callback_count);
 }
 #endif  // OS_ANDROID
 
 }  // namespace
 }  // namespace cc