[Android WebView] Update SW rendering to use SkPicture and fix scrolling cases.

android_webview/native/aw_contents.cc

 // Copyright (c) 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 "android_webview/native/aw_contents.h"
 
 #include <sys/system_properties.h>
 
 #include "android_webview/browser/aw_browser_main_parts.h"
 #include "android_webview/browser/net_disk_cache_remover.h"
@@ skipping 142 matching lines @@
 AwContents::AwContents(JNIEnv* env,
                        jobject obj,
                        jobject web_contents_delegate,
                        bool private_browsing)
     : java_ref_(env, obj),
       web_contents_delegate_(
           new AwWebContentsDelegate(env, web_contents_delegate)),
       view_visible_(false),
       compositor_visible_(false),
       is_composite_pending_(false),
-      last_scroll_x_(0), last_scroll_y_(0),
       last_frame_context_(NULL) {
   RendererPictureMap::CreateInstance();
   android_webview::AwBrowserDependencyFactory* dependency_factory =
       android_webview::AwBrowserDependencyFactory::GetInstance();
 
   // TODO(joth): rather than create and set the WebContents here, expose the
   // factory method to java side and have that orchestrate the construction
   // order.
   SetWebContents(dependency_factory->CreateWebContents(private_browsing));
 }
@@ skipping 132 matching lines @@
     LOG(WARNING) << "No current context attached. Skipping composite.";
     return;
   }
 
   if (last_frame_context_ != current_context) {
     if (last_frame_context_)
       ResetCompositor();
     last_frame_context_ = current_context;
   }
 
-  gfx::Transform transform;
   compositor_->SetWindowBounds(gfx::Size(draw_info->width, draw_info->height));
 
   if (draw_info->is_layer) {
     // When rendering into a separate layer no view clipping, transform,
     // scissoring or background transparency need to be handled.
     // The Android framework will composite us afterwards.
     compositor_->SetHasTransparentBackground(false);
     view_clip_layer_->setMasksToBounds(false);
+    transform_layer_->setTransform(gfx::Transform());
     scissor_clip_layer_->setMasksToBounds(false);
     scissor_clip_layer_->setPosition(gfx::PointF());
     scissor_clip_layer_->setBounds(gfx::Size());
     scissor_clip_layer_->setSublayerTransform(gfx::Transform());
 
   } else {
     compositor_->SetHasTransparentBackground(true);
 
     gfx::Rect clip_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);
 
     scissor_clip_layer_->setPosition(clip_rect.origin());
     scissor_clip_layer_->setBounds(clip_rect.size());
     scissor_clip_layer_->setMasksToBounds(true);
 
     // The compositor clipping architecture enforces us to have the clip layer
     // as an ancestor of the area we want to clip, but this makes the transform
     // become relative to the clip area rather than the full surface. The clip
     // position offset needs to be undone before applying the transform.
     gfx::Transform undo_clip_position;
     undo_clip_position.Translate(-clip_rect.x(), -clip_rect.y());
     scissor_clip_layer_->setSublayerTransform(undo_clip_position);
 
+    gfx::Transform transform;
     transform.matrix().setColMajorf(draw_info->transform);
+
+    // The scrolling values of the Android Framework affect the transformation
+    // matrix. This needs to be undone to let the compositor handle scrolling.
+    transform.Translate(hw_rendering_scroll_.x(), hw_rendering_scroll_.y());
+    transform_layer_->setTransform(transform);
+
     view_clip_layer_->setMasksToBounds(true);
   }
 
-  // The scrolling values of the Android Framework affect the transformation
-  // matrix. This needs to be undone to let the compositor handle scrolling.
-  transform.Translate(last_scroll_x_, last_scroll_y_);
-  transform_layer_->setTransform(transform);
-
   compositor_->Composite();
   is_composite_pending_ = false;
 
   // TODO(leandrogracia): remove when crbug.com/164140 is closed.
   // ---------------------------------------------------------------------------
   char no_gl_restore_prop[PROP_VALUE_MAX];
   __system_property_get("webview.chromium_no_gl_restore", no_gl_restore_prop);
   if (!strcmp(no_gl_restore_prop, "true")) {
     LOG(WARNING) << "Android GL functor not restoring the previous GL state.";
   } else {
@@ skipping 46 matching lines @@
       glDisable(GL_SCISSOR_TEST);
 
     glScissor(scissor_box[0], scissor_box[1], scissor_box[2],
                      scissor_box[3]);
 
     glUseProgram(current_program);
   }
   // ---------------------------------------------------------------------------
 }
 
-bool AwContents::DrawSW(JNIEnv* env, jobject obj, jobject java_canvas) {
+bool AwContents::DrawSW(JNIEnv* env, jobject obj, jobject java_canvas,
+                        jint scroll_x, jint scroll_y) {
   scoped_refptr<cc::PicturePileImpl> picture =
       RendererPictureMap::GetInstance()->GetRendererPicture(
           web_contents_->GetRoutingID());
   if (!picture)
     return false;
 
   AwPixelInfo* pixels;
   if (!g_draw_sw_functions ||
       (pixels = g_draw_sw_functions->access_pixels(env, java_canvas)) == NULL) {
     // TODO(joth): Fall back to slow path rendering via temporary bitmap.
     return false;
   }
 
   {
     SkBitmap bitmap;
     bitmap.setConfig(static_cast<SkBitmap::Config>(pixels->config),
                      pixels->width,
                      pixels->height,
                      pixels->row_bytes);
     bitmap.setPixels(pixels->pixels);
     SkDevice device(bitmap);
     SkCanvas canvas(&device);
     SkMatrix matrix;
     for (int i = 0; i < 9; i++) {
       matrix.set(i, pixels->matrix[i]);
     }
     canvas.setMatrix(matrix);
 
+    // Scroll needs to be undone to let the Chrome compositor handle scrolling.
+    canvas.translate(scroll_x, scroll_y);

[Leandro Graciá Gil, 2013/01/04 21:21:24]

As part of the review of https://codereview.chromium.org/11731002/ I'll be
replacing all PicturePileImpl directly with SkPictures. It happens that then we
will translate the scroll to immediately undo that as PicturePileImpl::Raster
did to position itself correctly within the content.

So, apparently this translate and any references to scroll offsets in SW mode
can be removed and scroll will be automatically fixed when adopting SkPictures.
I'll update the patch.

+
     SkRegion clip;
     if (pixels->clip_region_size) {
       size_t bytes_read = clip.readFromMemory(pixels->clip_region);
       DCHECK_EQ(pixels->clip_region_size, bytes_read);
       canvas.setClipRegion(clip);
     } else {
       clip.setRect(SkIRect::MakeWH(pixels->width, pixels->height));
     }
 
-    SkIRect sk_clip_rect = clip.getBounds();
-    gfx::Rect clip_rect(sk_clip_rect.x(), sk_clip_rect.y(),
-                        sk_clip_rect.width(), sk_clip_rect.height());
-
     cc::RenderingStats stats;
-    picture->Raster(&canvas, clip_rect, 1.0, &stats);
+    gfx::Rect content_rect(scroll_x, scroll_y, view_size_.width(),
+                           view_size_.height());
+    picture->Raster(&canvas, content_rect, 1.0, &stats);
   }
 
   g_draw_sw_functions->release_pixels(pixels);
   return true;
 }
 
 jint AwContents::GetWebContents(JNIEnv* env, jobject obj) {
   return reinterpret_cast<jint>(web_contents_.get());
 }
 
@@ skipping 375 matching lines @@
 
   Pickle pickle(reinterpret_cast<const char*>(state_vector.begin()),
                 state_vector.size());
   PickleIterator iterator(pickle);
 
   return RestoreFromPickle(&iterator, web_contents_.get());
 }
 
 void AwContents::SetScrollForHWFrame(JNIEnv* env, jobject obj,
                                      int scroll_x, int scroll_y) {
-  last_scroll_x_ = scroll_x;
-  last_scroll_y_ = scroll_y;
+  hw_rendering_scroll_ = gfx::Point(scroll_x, scroll_y);
 }
 
 void AwContents::SetPendingWebContentsForPopup(
     scoped_ptr<content::WebContents> pending) {
   if (pending_contents_.get()) {
     // TODO(benm): Support holding multiple pop up window requests.
     LOG(WARNING) << "Blocking popup window creation as an outstanding "
                  << "popup window is still pending.";
     MessageLoop::current()->DeleteSoon(FROM_HERE, pending.release());
     return;
@@ skipping 11 matching lines @@
 
 void AwContents::OnPictureUpdated(int process_id, int render_view_id) {
   CHECK_EQ(web_contents_->GetRenderProcessHost()->GetID(), process_id);
   if (render_view_id != web_contents_->GetRoutingID())
     return;
 
   Invalidate();
 }
 
 }  // namespace android_webview