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 148 matching lines @@
     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 1.f;

[danakj, 2013/05/22 14:08:42]

Can we have a test where this is != 1?

[ccameron, 2013/05/22 18:26:11]

The test wasn't verifying any of the Reshape arguments before (viewport size is
always 1x1) ... I've added a test that verifies the size and the 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 1251 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);
+    EXPECT_CALL(output_surface_, Reshape(_, _)).Times(1);
 
     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());
   }
 
@@ skipping 109 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