Delegate root layer scroll offset to android_webview.

content/renderer/android/synchronous_compositor_output_surface.cc

 // Copyright (c) 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 "content/renderer/android/synchronous_compositor_output_surface.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/time.h"
 #include "cc/output/compositor_frame.h"
@@ skipping 69 matching lines @@
 
  private:
   SynchronousCompositorOutputSurface* surface_;
   SkDevice null_device_;
   SkCanvas null_canvas_;
 
   DISALLOW_COPY_AND_ASSIGN(SoftwareDevice);
 };
 
 SynchronousCompositorOutputSurface::SynchronousCompositorOutputSurface(
-    int32 routing_id)
-    : cc::OutputSurface(CreateWebGraphicsContext3D(),
-                        scoped_ptr<cc::SoftwareOutputDevice>(
-                            new SoftwareDevice(this))),
-      compositor_client_(NULL),
-      routing_id_(routing_id),
+    Delegate* delegate)
+    : cc::OutputSurface(
+          CreateWebGraphicsContext3D(),
+          scoped_ptr<cc::SoftwareOutputDevice>(new SoftwareDevice(this))),
+      delegate_(delegate),
       vsync_enabled_(false),
       did_swap_buffer_(false),
       current_sw_canvas_(NULL) {
   capabilities_.deferred_gl_initialization = true;
 }
 
 SynchronousCompositorOutputSurface::~SynchronousCompositorOutputSurface() {
   DCHECK(CalledOnValidThread());
-  if (compositor_client_)
-    compositor_client_->DidDestroyCompositor(this);
+  delegate_->DidDestroyCompositor();
 }
 
 bool SynchronousCompositorOutputSurface::ForcedDrawToSoftwareDevice() const {
   return current_sw_canvas_ != NULL;
 }
 
 bool SynchronousCompositorOutputSurface::BindToClient(
     cc::OutputSurfaceClient* surface_client) {
   DCHECK(CalledOnValidThread());
   if (!cc::OutputSurface::BindToClient(surface_client))
     return false;
-  GetContentClient()->renderer()->DidCreateSynchronousCompositor(routing_id_,
-                                                                 this);
+  delegate_->DidCreateSynchronousCompositor();
   return true;
 }
 
 void SynchronousCompositorOutputSurface::Reshape(gfx::Size size) {
   // Intentional no-op: surface size is controlled by the embedder.
 }
 
 void SynchronousCompositorOutputSurface::SendFrameToParentCompositor(
     cc::CompositorFrame* frame) {
   NOTREACHED();
   // TODO(joth): Route page scale to the client, see http://crbug.com/237006
 }
 
 void SynchronousCompositorOutputSurface::EnableVSyncNotification(
     bool enable_vsync) {
   DCHECK(CalledOnValidThread());
   vsync_enabled_ = enable_vsync;
-  UpdateCompositorClientSettings();
+  delegate_->SetContinuousInvalidate(enable_vsync);
 }
 
 void SynchronousCompositorOutputSurface::SwapBuffers(
     const cc::LatencyInfo& info) {
   context3d()->shallowFlushCHROMIUM();
   did_swap_buffer_ = true;
 }
 
-void SynchronousCompositorOutputSurface::SetClient(
-    SynchronousCompositorClient* compositor_client) {
-  DCHECK(CalledOnValidThread());
-  compositor_client_ = compositor_client;
-  UpdateCompositorClientSettings();
-}
-
 bool SynchronousCompositorOutputSurface::IsHwReady() {
   return context3d() != NULL;
 }
 
 bool SynchronousCompositorOutputSurface::DemandDrawSw(SkCanvas* canvas) {
   DCHECK(CalledOnValidThread());
   DCHECK(canvas);
   DCHECK(!current_sw_canvas_);
   current_sw_canvas_ = canvas;
 
@@ skipping 32 matching lines @@
 void SynchronousCompositorOutputSurface::InvokeComposite(
     const gfx::Transform& transform,
     gfx::Rect damage_area) {
   // TODO(boliu): This assumes |transform| is identity and |damage_area| is the
   // whole view. Tracking bug to implement this: crbug.com/230463.
   client_->SetNeedsRedrawRect(damage_area);
   if (vsync_enabled_)
     client_->DidVSync(base::TimeTicks::Now());
 }
 
-void SynchronousCompositorOutputSurface::UpdateCompositorClientSettings() {
-  if (compositor_client_) {
-    compositor_client_->SetContinuousInvalidate(vsync_enabled_);
-  }
-}
-
 // Not using base::NonThreadSafe as we want to enforce a more exacting threading
 // requirement: SynchronousCompositorOutputSurface() must only be used by
 // embedders that supply their own compositor loop via
 // OverrideCompositorMessageLoop().
 bool SynchronousCompositorOutputSurface::CalledOnValidThread() const {
   return base::MessageLoop::current() && (base::MessageLoop::current() ==
       GetContentClient()->renderer()->OverrideCompositorMessageLoop());
 }
 
 }  // namespace content