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/scoped_app_gl_state_restore.h"
 #include "android_webview/public/browser/draw_gl.h"
@@ skipping 258 matching lines @@
       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));
   block_invalidates_ = false;
 
   EnsureContinuousInvalidation(draw_info);
 }
 
 bool InProcessViewRenderer::DrawSWInternal(jobject java_canvas,
                                            const gfx::Rect& clip) {

[Kristian Monsen, 2013/07/25 03:35:17]

This is now only used for the early out, do we still need it?

[joth, 2013/08/04 06:04:08]

still needed for the RasterizeIntoBitmap() call

   TRACE_EVENT0("android_webview", "InProcessViewRenderer::DrawSW");
   fallback_tick_.Cancel();
 
   if (clip.IsEmpty()) {
     TRACE_EVENT_INSTANT0(
         "android_webview", "EarlyOut_EmptyClip", TRACE_EVENT_SCOPE_THREAD);
     return true;
   }
 
   if (!compositor_) {
     TRACE_EVENT_INSTANT0(
         "android_webview", "EarlyOut_NoCompositor", TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   JNIEnv* env = AttachCurrentThread();

[Kristian Monsen, 2013/07/25 03:35:17]

I think this is only needed for the kNo_Config?

[joth, 2013/08/04 06:04:08]

Done.

[joth, 2013/08/10 00:54:50]

...actually, is needed for sw_functions->access_pixel

 
   AwDrawSWFunctionTable* sw_functions = GetAwDrawSWFunctionTable();
   AwPixelInfo* pixels = sw_functions ?
       sw_functions->access_pixels(env, java_canvas) : NULL;
-  // Render into an auxiliary bitmap if pixel info is not available.
-  ScopedJavaLocalRef<jobject> jcanvas(env, java_canvas);
-  if (pixels == NULL) {
+  SkBitmap::Config config = !pixels ? SkBitmap::kNo_Config :
+      pixels->config == AwConfig_ARGB_8888 ? SkBitmap::kARGB_8888_Config :
+      pixels->config == AwConfig_ARGB_4444 ? SkBitmap::kARGB_4444_Config :
+      pixels->config == AwConfig_RGB_565 ? SkBitmap::kRGB_565_Config :
+      SkBitmap::kNo_Config;
+  if (config == SkBitmap::kNo_Config) {
+    // 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, web_contents_));
     if (!jbitmap.obj()) {
       TRACE_EVENT_INSTANT0("android_webview",
                            "EarlyOut_BitmapAllocFail",
                            TRACE_EVENT_SCOPE_THREAD);
       return false;
     }
 
@@ skipping 10 matching lines @@
 
     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),
+    bitmap.setConfig(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);
 
-    if (pixels->clip_region_size) {
+    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.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);
     } else {
+      NOTREACHED();
+      // The |clip| passed in is relative to the canvas, not necessarily to
+      // |pixels|, so in general it's not safe to use it as a fallback.
       canvas.clipRect(gfx::RectToSkRect(clip));
     }
     canvas.translate(scroll_at_start_of_frame_.x(),
                      scroll_at_start_of_frame_.y());
 
     succeeded = CompositeSW(&canvas);
   }
 
   sw_functions->release_pixels(pixels);
   return succeeded;
@@ skipping 304 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