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"
 #include "base/android/jni_android.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "content/public/browser/android/content_view_core.h"
 #include "content/public/browser/android/synchronous_compositor.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/skia/include/core/SkGraphics.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
+#include "ui/gfx/vector2d_conversions.h"
 #include "ui/gfx/vector2d_f.h"
 #include "ui/gl/gl_bindings.h"
 
 // TODO(leandrogracia): Borrowed from gl2ext.h. Cannot be included due to
 // conflicts with  gl_bindings.h and the EGL library methods
 // (eglGetCurrentContext).
 #ifndef GL_TEXTURE_EXTERNAL_OES
 #define GL_TEXTURE_EXTERNAL_OES 0x8D65
 #endif
 
@@ skipping 261 matching lines @@
 
 InProcessViewRenderer::InProcessViewRenderer(
     BrowserViewRenderer::Client* client,
     JavaHelper* java_helper,
     content::WebContents* web_contents)
     : client_(client),
       java_helper_(java_helper),
       web_contents_(web_contents),
       compositor_(NULL),
       view_visible_(false),
+      dip_scale_(0.0),
       continuous_invalidate_(false),
       block_invalidates_(false),
       width_(0),
       height_(0),
       attached_to_window_(false),
       hardware_initialized_(false),
       hardware_failed_(false),
       last_egl_context_(NULL) {
   CHECK(web_contents_);
   web_contents_->SetUserData(kUserDataKey, new UserData(this));
@@ skipping 15 matching lines @@
   return UserData::GetInstance(contents);
 }
 
 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,
                                    const gfx::Rect& clip) {
   scroll_at_start_of_frame_  = scroll;
   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
   block_invalidates_ = true;
   bool result = DrawSWInternal(java_canvas, clip);
@@ skipping 281 matching lines @@
   TRACE_EVENT_INSTANT1("android_webview",
                        "InProcessViewRenderer::SetContinuousInvalidate",
                        TRACE_EVENT_SCOPE_THREAD,
                        "invalidate",
                        invalidate);
   continuous_invalidate_ = invalidate;
   // TODO(boliu): Handle if not attached to window case.
   EnsureContinuousInvalidation(NULL);
 }
 
+void InProcessViewRenderer::SetDipScale(float dip_scale) {
+  dip_scale_ = dip_scale;
+  CHECK(dip_scale_ > 0);
+}
+
+void InProcessViewRenderer::ScrollTo(gfx::Vector2d new_value) {
+  DCHECK(dip_scale_ > 0);
+  // In general we don't guarantee that the scroll offset transforms are
+  // symmetrical. That is if scrolling from JS to offset1 results in a native
+  // offset2 then scrolling from UI to offset2 results in JS being scrolled to
+  // offset1 again.
+  // The reason we explicitly do rounding here is that it seems to yeld the
+  // most stabile transformation.
+  gfx::Vector2dF new_value_css = gfx::ToRoundedVector2d(
+      gfx::ScaleVector2d(new_value, 1.0f / dip_scale_));
+
+  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) {
+  // TOOD(mkosiba): Add a DCHECK to say that this does _not_ get called during
+  // DrawGl when http://crbug.com/249972 is fixed.
+  if (scroll_offset_css_ == new_value_css)
+    return;
+
+  scroll_offset_css_ = new_value_css;
+
+  DCHECK(dip_scale_ > 0);
+
+  gfx::Vector2d scroll_offset =
+      gfx::ToRoundedVector2d(gfx::ScaleVector2d(new_value_css, dip_scale_));
+
+  client_->ScrollContainerViewTo(scroll_offset);
 }
 
 gfx::Vector2dF InProcessViewRenderer::GetTotalRootLayerScrollOffset() {
-  return scroll_offset_;
+  return scroll_offset_css_;
 }
 
 void InProcessViewRenderer::EnsureContinuousInvalidation(
     AwDrawGLInfo* draw_info) {
   if (continuous_invalidate_ && !block_invalidates_) {
     if (draw_info) {
       draw_info->dirty_left = draw_info->clip_left;
       draw_info->dirty_top = draw_info->clip_top;
       draw_info->dirty_right = draw_info->clip_right;
       draw_info->dirty_bottom = draw_info->clip_bottom;
       draw_info->status_mask |= AwDrawGLInfo::kStatusMaskDraw;
     } else {
       client_->PostInvalidate();
     }
     block_invalidates_ = 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