Hookup android_webview scroll offset delegation to Java side.

android_webview/browser/in_process_view_renderer.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 "android_webview/browser/in_process_view_renderer.h"
 
 #include <android/bitmap.h>
 
 #include "android_webview/public/browser/draw_gl.h"
 #include "android_webview/public/browser/draw_sw.h"
@@ skipping 336 matching lines @@
   // until the DidInitializeCompositor() call, hence it is not set here.
 }
 
 void InProcessViewRenderer::WebContentsGone() {
   web_contents_ = NULL;
   compositor_ = NULL;
 }
 
 bool InProcessViewRenderer::OnDraw(jobject java_canvas,
                                    bool is_hardware_canvas,
-                                   const gfx::Point& scroll,
+                                   const gfx::Vector2d& scroll_pix,
                                    const gfx::Rect& clip) {
-  scroll_at_start_of_frame_  = scroll;
+  scroll_at_start_of_frame_pix_  = scroll_pix;
   if (is_hardware_canvas && attached_to_window_ && compositor_ &&
       HardwareEnabled() && client_->RequestDrawGL(java_canvas)) {
     // All set: we'll get a call on DrawGL when the time comes.
     return true;
   }
   // Perform a software draw
   bool result = DrawSWInternal(java_canvas, clip);
   EnsureContinuousInvalidation();
   return result;
 }
@@ skipping 30 matching lines @@
     // TODO(boliu): Handle context lost
   }
 
   // TODO(boliu): Make sure this is not called before compositor is initialized
   // and GL is ready. Then make this a DCHECK.
   if (!compositor_)
     return;
 
   gfx::Transform transform;
   transform.matrix().setColMajorf(draw_info->transform);
-  transform.Translate(scroll_at_start_of_frame_.x(),
-                      scroll_at_start_of_frame_.y());
+  transform.Translate(scroll_at_start_of_frame_pix_.x(),
+                      scroll_at_start_of_frame_pix_.y());
   // TODO(joth): Check return value.
   compositor_->DemandDrawHw(
       gfx::Size(draw_info->width, draw_info->height),
       transform,
       gfx::Rect(draw_info->clip_left,
                 draw_info->clip_top,
                 draw_info->clip_right - draw_info->clip_left,
                 draw_info->clip_bottom - draw_info->clip_top));
 
   EnsureContinuousInvalidation();
@@ skipping 19 matching lines @@
     TRACE_EVENT0("android_webview", "Render to Aux Bitmap");
     ScopedJavaLocalRef<jobject> jbitmap(java_helper_->CreateBitmap(
         env, clip.width(), clip.height()));
     if (!jbitmap.obj()) {
       TRACE_EVENT_INSTANT0("android_webview", "Bitmap Alloc Fail",
                            TRACE_EVENT_SCOPE_THREAD);
       return false;
     }
 
     if (!RasterizeIntoBitmap(env, jbitmap,
-                             clip.x() - scroll_at_start_of_frame_.x(),
-                             clip.y() - scroll_at_start_of_frame_.y(),
+                             clip.x() - scroll_at_start_of_frame_pix_.x(),
+                             clip.y() - scroll_at_start_of_frame_pix_.y(),
                              base::Bind(&InProcessViewRenderer::RenderSW,
                                         base::Unretained(this)))) {
+
       TRACE_EVENT_INSTANT0("android_webview", "Rasterize Fail",
                            TRACE_EVENT_SCOPE_THREAD);
       return false;
     }
 
     ScopedJavaLocalRef<jobject> jcanvas(env, java_canvas);
     java_helper_->DrawBitmapIntoCanvas(env, jbitmap, jcanvas,
                                        clip.x(), clip.y());
     return true;
   }
@@ skipping 15 matching lines @@
     canvas.setMatrix(matrix);
 
     if (pixels->clip_region_size) {
       SkRegion clip_region;
       size_t bytes_read = clip_region.readFromMemory(pixels->clip_region);
       DCHECK_EQ(pixels->clip_region_size, bytes_read);
       canvas.setClipRegion(clip_region);
     } else {
       canvas.clipRect(gfx::RectToSkRect(clip));
     }
-    canvas.translate(scroll_at_start_of_frame_.x(),
-                     scroll_at_start_of_frame_.y());
+    canvas.translate(scroll_at_start_of_frame_pix_.x(),
+                     scroll_at_start_of_frame_pix_.y());
 
     succeeded = RenderSW(&canvas);
   }
 
   sw_functions->release_pixels(pixels);
   return succeeded;
 }
 
 base::android::ScopedJavaLocalRef<jobject>
 InProcessViewRenderer::CapturePicture() {
@@ skipping 69 matching lines @@
   attached_to_window_ = false;
 }
 
 bool InProcessViewRenderer::IsAttachedToWindow() {
   return attached_to_window_;
 }
 
 bool InProcessViewRenderer::IsViewVisible() {
   return view_visible_;
 }
-

[joth, 2013/06/18 03:19:50]

mistake?

[mkosiba (inactive), 2013/06/18 18:09:25]

yes

 gfx::Rect InProcessViewRenderer::GetScreenRect() {
   return gfx::Rect(client_->GetLocationOnScreen(), gfx::Size(width_, height_));
 }
 
 void InProcessViewRenderer::DidInitializeCompositor(
     content::SynchronousCompositor* compositor) {
   DCHECK(compositor && compositor_ == NULL);
   compositor_ = compositor;
   hardware_initialized_ = false;
   hardware_failed_ = false;
@@ skipping 10 matching lines @@
 
 void InProcessViewRenderer::SetContinuousInvalidate(bool invalidate) {
   if (continuous_invalidate_ == invalidate)
     return;
 
   continuous_invalidate_ = invalidate;
   // TODO(boliu): Handle if not attached to window case.
   EnsureContinuousInvalidation();
 }
 
+void InProcessViewRenderer::ScrollTo(gfx::Vector2dF new_value_css) {
+  DCHECK(scroll_offset_css_ != new_value_css);
+
+  scroll_offset_css_ = new_value_css;
+
+  if (compositor_)
+    compositor_->DidChangeRootLayerScrollOffset();
+}
+
 void InProcessViewRenderer::SetTotalRootLayerScrollOffset(
-    gfx::Vector2dF new_value) {
-  // TODO(mkosiba): Plumb this all the way through to the view.
-  scroll_offset_ = new_value;
+    gfx::Vector2dF new_value_css) {
+  bool value_changed = scroll_offset_css_ != new_value_css;
+
+  if (!value_changed)
+    return;
+
+  scroll_offset_css_ = new_value_css;
+
+  client_->ScrollContainerViewTo(new_value_css);
 }
 
 gfx::Vector2dF InProcessViewRenderer::GetTotalRootLayerScrollOffset() {
-  return scroll_offset_;
+  return scroll_offset_css_;
 }
 
 void InProcessViewRenderer::Invalidate() {
   continuous_invalidate_task_pending_ = false;
   if (continuous_invalidate_)
     client_->Invalidate();
 }
 
 void InProcessViewRenderer::EnsureContinuousInvalidation() {
   if (continuous_invalidate_ && !continuous_invalidate_task_pending_) {
     base::MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(&InProcessViewRenderer::Invalidate,
                    weak_factory_.GetWeakPtr()));
     continuous_invalidate_task_pending_ = true;
   }
 }
 
 bool InProcessViewRenderer::RenderSW(SkCanvas* canvas) {
   // TODO(joth): BrowserViewRendererImpl had a bunch of logic for dpi and page
   // scale here. Determine what if any needs bringing over to this class.
   return CompositeSW(canvas);
 }
 
 bool InProcessViewRenderer::CompositeSW(SkCanvas* canvas) {
   return compositor_ && compositor_->DemandDrawSw(canvas);
 }
 
 }  // namespace android_webview