Fix UpdateTilePriorities viewport in Android WebView.

cc/test/pixel_test.cc

 // Copyright 2013 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/test/pixel_test.h"
 
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/copy_output_request.h"
@@ skipping 10 matching lines @@
 #include "ui/gl/gl_implementation.h"
 #include "webkit/common/gpu/context_provider_in_process.h"
 #include "webkit/common/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
 
 namespace cc {
 
 class PixelTest::PixelTestRendererClient
     : public RendererClient, public OutputSurfaceClient {
  public:
   explicit PixelTestRendererClient(gfx::Rect device_viewport)
-      : device_viewport_(device_viewport), stencil_enabled_(false) {}
+      : device_viewport_(device_viewport),
+        device_clip_(device_viewport),
+        stencil_enabled_(false) {}
 
   // RendererClient implementation.
   virtual gfx::Rect DeviceViewport() const OVERRIDE {
     return device_viewport_;
   }
+  virtual gfx::Rect DeviceClip() const OVERRIDE {
+    return device_clip_;
+  }
   virtual float DeviceScaleFactor() const OVERRIDE {
     return 1.f;
   }
   virtual const LayerTreeSettings& Settings() const OVERRIDE {
     return settings_;
   }
   virtual void SetFullRootLayerDamage() OVERRIDE {}
   virtual bool HasImplThread() const OVERRIDE { return false; }
   virtual bool ShouldClearRootRenderPass() const OVERRIDE { return true; }
   virtual CompositorFrameMetadata MakeCompositorFrameMetadata() const
@@ skipping 10 matching lines @@
   // OutputSurfaceClient implementation.
   virtual bool DeferredInitialize(
       scoped_refptr<ContextProvider> offscreen_context_provider) OVERRIDE {
     return false;
   }
   virtual void ReleaseGL() OVERRIDE {}
   virtual void SetNeedsRedrawRect(gfx::Rect damage_rect) OVERRIDE {}
   virtual void BeginFrame(const BeginFrameArgs& args) OVERRIDE {}
   virtual void OnSwapBuffersComplete(const CompositorFrameAck* ack) OVERRIDE {}
   virtual void DidLoseOutputSurface() OVERRIDE {}
-  virtual void SetExternalDrawConstraints(const gfx::Transform& transform,
-                                          gfx::Rect viewport) OVERRIDE {
+  virtual void SetExternalDrawConstraints(
+      const gfx::Transform& transform,
+      gfx::Rect viewport,
+      gfx::Rect clip,
+      bool valid_for_tile_management) OVERRIDE {
     device_viewport_ = viewport;
+    device_clip_ = clip;
   }
   virtual void SetExternalStencilTest(bool enable) OVERRIDE {
     stencil_enabled_ = enable;
   }
   virtual void SetMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE {}
   virtual void SetDiscardBackBufferWhenNotVisible(bool discard) OVERRIDE {}
   virtual void SetTreeActivationCallback(const base::Closure&) OVERRIDE {}
 
  private:
   gfx::Rect device_viewport_;
+  gfx::Rect device_clip_;
   bool stencil_enabled_;
   LayerTreeSettings settings_;
 };
 
 PixelTest::PixelTest()
     : device_viewport_size_(gfx::Size(200, 200)),
       fake_client_(
           new PixelTestRendererClient(gfx::Rect(device_viewport_size_))) {}
 
 PixelTest::~PixelTest() {}
@@ skipping 91 matching lines @@
       ->set_surface_expansion_size(surface_expansion);
   static_cast<PixelTestOutputSurface*>(output_surface_.get())
       ->set_viewport_offset(viewport_offset);
   SoftwareOutputDevice* device = output_surface_->software_device();
   if (device) {
     static_cast<PixelTestSoftwareOutputDevice*>(device)
         ->set_surface_expansion_size(surface_expansion);
   }
 }
 
+void PixelTest::ForceDeviceClip(gfx::Rect clip) {
+  static_cast<PixelTestOutputSurface*>(output_surface_.get())
+      ->set_device_clip(clip);
+}
+
 void PixelTest::EnableExternalStencilTest() {
   fake_client_->SetExternalStencilTest(true);
 }
 
 void PixelTest::SetUpSoftwareRenderer() {
   CHECK(fake_client_);
 
   scoped_ptr<SoftwareOutputDevice> device(new PixelTestSoftwareOutputDevice());
   output_surface_.reset(new PixelTestOutputSurface(device.Pass()));
   output_surface_->BindToClient(fake_client_.get());
   resource_provider_ = ResourceProvider::Create(output_surface_.get(), 0);
   renderer_ = SoftwareRenderer::Create(
       fake_client_.get(),
       output_surface_.get(),
       resource_provider_.get()).PassAs<DirectRenderer>();
 }
 
 }  // namespace cc