Make the AwPixelInfo more skia version independent

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/browser/aw_gl_surface.h"
 #include "android_webview/browser/scoped_app_gl_state_restore.h"
@@ skipping 92 matching lines @@
   }
 
   return succeeded;
 }
 
 bool RenderPictureToCanvas(SkPicture* picture, SkCanvas* canvas) {
   canvas->drawPicture(*picture);
   return true;
 }
 
+class ScopedPixelAccess {
+ public:
+  ScopedPixelAccess(JNIEnv* env, jobject java_canvas) {
+    AwDrawSWFunctionTable* sw_functions =
+        BrowserViewRenderer::GetAwDrawSWFunctionTable();
+    pixels_ = sw_functions ?
+      sw_functions->access_pixels(env, java_canvas) : NULL;
+  }
+  ~ScopedPixelAccess() {
+    if (pixels_)
+      BrowserViewRenderer::GetAwDrawSWFunctionTable()->release_pixels(pixels_);
+  }
+  AwPixelInfo* pixels() { return pixels_; }
+
+ private:
+  AwPixelInfo* pixels_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(ScopedPixelAccess);
+};
+
 bool HardwareEnabled() {
   static bool g_hw_enabled = !CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableWebViewGLMode);
   return g_hw_enabled;
 }
 
 // Provides software rendering functions from the Android glue layer.
 // Allows preventing extra copies of data when rendering.
 AwDrawSWFunctionTable* g_sw_draw_functions = NULL;
 
@@ skipping 283 matching lines @@
 // static
 bool InProcessViewRenderer::RenderViaAuxilaryBitmapIfNeeded(
       jobject java_canvas,
       BrowserViewRenderer::JavaHelper* java_helper,
       const gfx::Vector2d& scroll_correction,
       const gfx::Rect& clip,
       InProcessViewRenderer::RenderMethod render_source,
       void* owner_key) {
   TRACE_EVENT0("android_webview",
                "InProcessViewRenderer::RenderViaAuxilaryBitmapIfNeeded");
+
   JNIEnv* env = AttachCurrentThread();
+  ScopedPixelAccess auto_release_pixels(env, java_canvas);
+  AwPixelInfo* pixels = auto_release_pixels.pixels();
+  SkMatrix matrix;
+  SkBitmap::Config config(SkBitmap::kNo_Config);
+  if (pixels) {
+    switch (pixels->config) {
+      case AwConfig_ARGB_8888:
+        config = SkBitmap::kARGB_8888_Config;
+        break;
+      case AwConfig_RGB_565:
+        config = SkBitmap::kRGB_565_Config;
+        break;
+    }
 
-  AwDrawSWFunctionTable* sw_functions = GetAwDrawSWFunctionTable();
-  AwPixelInfo* pixels = sw_functions ?
-      sw_functions->access_pixels(env, java_canvas) : NULL;
-  if (pixels == NULL) {
+    for (int i = 0; i < 9; i++) {
+      matrix.set(i, pixels->matrix[i]);
+    }
+    // Workaround for http://crbug.com/271096: SW draw only supports
+    // translate & scale transforms.
+    if (matrix.getType() & ~(SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask))
+      config = SkBitmap::kNo_Config;
+  }
+
+  if (config == SkBitmap::kNo_Config) {

[boliu, 2013/08/10 01:41:40]

can this be the else block to "if (pixels)" on line 442?

[joth, 2013/08/10 01:45:48]

no - line 445, 448 and 458 all assign to |config| and so will affect the outcome

     // Render into an auxiliary bitmap if pixel info is not available.
     ScopedJavaLocalRef<jobject> jcanvas(env, java_canvas);
     TRACE_EVENT0("android_webview", "RenderToAuxBitmap");
     ScopedJavaLocalRef<jobject> jbitmap(java_helper->CreateBitmap(
         env, clip.width(), clip.height(), jcanvas, owner_key));
     if (!jbitmap.obj()) {
       TRACE_EVENT_INSTANT0("android_webview",
                            "EarlyOut_BitmapAllocFail",
                            TRACE_EVENT_SCOPE_THREAD);
       return false;
     }
 
     if (!RasterizeIntoBitmap(env, jbitmap,
                              clip.x() - scroll_correction.x(),
                              clip.y() - scroll_correction.y(),
                              render_source)) {
       TRACE_EVENT_INSTANT0("android_webview",
                            "EarlyOut_RasterizeFail",
                            TRACE_EVENT_SCOPE_THREAD);
       return false;
     }
 
     java_helper->DrawBitmapIntoCanvas(env, jbitmap, jcanvas,
                                       clip.x(), clip.y());
     return true;
   }
 
   // Draw in a SkCanvas built over the pixel information.
-  bool succeeded = 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);
+  SkBitmap bitmap;
+  bitmap.setConfig(config,
+                   pixels->width,
+                   pixels->height,
+                   pixels->row_bytes);
+  bitmap.setPixels(pixels->pixels);
+  SkDevice device(bitmap);
+  SkCanvas canvas(&device);
+  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));
+  if (pixels->clip_rect_count) {
+    SkRegion clip;
+    for (int i = 0; i < pixels->clip_rect_count; ++i) {
+      clip.op(SkIRect::MakeXYWH(pixels->clip_rects[i + 0],
+                                pixels->clip_rects[i + 1],
+                                pixels->clip_rects[i + 2],
+                                pixels->clip_rects[i + 3]),
+              SkRegion::kUnion_Op);
     }
-    canvas.translate(scroll_correction.x(),
-                     scroll_correction.y());
+    canvas.setClipRegion(clip);
+  } else if (pixels->clip_region && 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);
+  }
+  canvas.translate(scroll_correction.x(),
+                   scroll_correction.y());
 
-    succeeded = render_source.Run(&canvas);
-  }
-
-  sw_functions->release_pixels(pixels);
-  return succeeded;
+  return render_source.Run(&canvas);
 }
 
 skia::RefPtr<SkPicture> InProcessViewRenderer::CapturePicture(int width,
                                                               int height) {
+  TRACE_EVENT0("android_webview", "InProcessViewRenderer::CapturePicture");
+
   // Return empty Picture objects for empty SkPictures.
   skia::RefPtr<SkPicture> picture = skia::AdoptRef(new SkPicture);
   if (width <= 0 || height <= 0) {
     return picture;
   }
 
   // Reset scroll back to the origin, will go back to the old
   // value when scroll_reset is out of scope.
   base::AutoReset<gfx::Vector2dF> scroll_reset(&scroll_offset_css_,
                                                gfx::Vector2d());
@@ skipping 288 matching lines @@
     base::StringAppendF(&str,
                         "surface width height: [%d %d] ",
                         draw_info->width,
                         draw_info->height);
     base::StringAppendF(&str, "is_layer: %d ", draw_info->is_layer);
   }
   return str;
 }
 
 }  // namespace android_webview