BackingStoreSkia: Use skia for painting in RenderWidgetHostViewViews.

chrome/browser/renderer_host/render_widget_host_view_views.cc

 // Copyright (c) 2010 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 "chrome/browser/renderer_host/render_widget_host_view_views.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/task.h"
 #include "base/time.h"
+#include "chrome/browser/renderer_host/backing_store_skia.h"
 #include "chrome/browser/renderer_host/backing_store_x.h"
 #include "chrome/browser/renderer_host/render_widget_host.h"
 #include "chrome/common/native_web_keyboard_event.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/result_codes.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/gtk/WebInputEventFactory.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "ui/base/keycodes/keyboard_code_conversion_gtk.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/canvas.h"
+#include "ui/gfx/canvas_skia.h"
 #include "views/event.h"
 #include "views/widget/widget.h"
 #include "views/widget/widget_gtk.h"
 
 static const int kMaxWindowWidth = 4000;
 static const int kMaxWindowHeight = 4000;
-static const char* kRenderWidgetHostViewKey = "__RENDER_WIDGET_HOST_VIEW__";
+static const char kRenderWidgetHostViewKey[] = "__RENDER_WIDGET_HOST_VIEW__";
+static const char kBackingStoreSkiaSwitch[] = "use-backing-store-skia";
 
 using WebKit::WebInputEventFactory;
 using WebKit::WebMouseWheelEvent;
 using WebKit::WebTouchEvent;
 
 namespace {
 
+bool UsingBackingStoreSkia() {
+  static bool decided = false;
+  static bool use_skia = false;
+  if (!decided) {
+    CommandLine* cmdline = CommandLine::ForCurrentProcess();
+    use_skia = (cmdline && cmdline->HasSwitch(kBackingStoreSkiaSwitch));
+    decided = true;
+  }
+
+  return use_skia;
+}
+
 int WebInputEventFlagsFromViewsEvent(const views::Event& event) {
   int modifiers = 0;
 
   if (event.IsShiftDown())
     modifiers |= WebKit::WebInputEvent::ShiftKey;
   if (event.IsControlDown())
     modifiers |= WebKit::WebInputEvent::ControlKey;
   if (event.IsAltDown())
     modifiers |= WebKit::WebInputEvent::AltKey;
   if (event.IsCapsLockDown())
@@ skipping 269 matching lines @@
 
 bool RenderWidgetHostViewViews::IsPopup() {
   return popup_type_ != WebKit::WebPopupTypeNone;
 }
 
 BackingStore* RenderWidgetHostViewViews::AllocBackingStore(
     const gfx::Size& size) {
   gfx::NativeView nview = GetInnerNativeView();
   if (!nview)
     return NULL;
-  return new BackingStoreX(host_, size,
-                           ui::GetVisualFromGtkWidget(nview),
-                           gtk_widget_get_visual(nview)->depth);
+
+  if (UsingBackingStoreSkia()) {
+    return new BackingStoreSkia(host_, size);
+  } else {
+    return new BackingStoreX(host_, size,
+                             ui::GetVisualFromGtkWidget(nview),
+                             gtk_widget_get_visual(nview)->depth);
+  }
 }
 
 gfx::NativeView RenderWidgetHostViewViews::GetInnerNativeView() const {
   // TODO(sad): Ideally this function should be equivalent to GetNativeView, and
   // WidgetGtk-specific function call should not be necessary.
   views::WidgetGtk* widget = static_cast<views::WidgetGtk*>(GetWidget());
   return widget ? widget->window_contents() : NULL;
 }
 
 gfx::NativeView RenderWidgetHostViewViews::GetNativeView() {
@@ skipping 29 matching lines @@
   GdkWindow* window = GetInnerNativeView()->window;
   DCHECK(!about_to_validate_and_paint_);
 
   // TODO(anicolao): get the damage somehow
   // invalid_rect_ = damage_rect;
   invalid_rect_ = bounds();
   gfx::Point origin;
   ConvertPointToWidget(this, &origin);
 
   about_to_validate_and_paint_ = true;
-  BackingStoreX* backing_store = static_cast<BackingStoreX*>(
-      host_->GetBackingStore(true));
+  BackingStore* backing_store = host_->GetBackingStore(true);
   // Calling GetBackingStore maybe have changed |invalid_rect_|...
   about_to_validate_and_paint_ = false;
 
   gfx::Rect paint_rect = gfx::Rect(0, 0, kMaxWindowWidth, kMaxWindowHeight);
   paint_rect = paint_rect.Intersect(invalid_rect_);
 
   if (backing_store) {
     // Only render the widget if it is attached to a window; there's a short
     // period where this object isn't attached to a window but hasn't been
     // Destroy()ed yet and it receives paint messages...
     if (window) {
       if (!visually_deemphasized_) {
         // In the common case, use XCopyArea. We don't draw more than once, so
         // we don't need to double buffer.
-        backing_store->XShowRect(origin,
-            paint_rect, ui::GetX11WindowFromGdkWindow(window));
-      } else {
+
+        if (UsingBackingStoreSkia()) {
+          static_cast<BackingStoreSkia*>(backing_store)->SkiaShowRect(
+              gfx::Point(paint_rect.x(), paint_rect.y()), canvas);
+        } else {
+          static_cast<BackingStoreX*>(backing_store)->XShowRect(origin,
+              paint_rect, ui::GetX11WindowFromGdkWindow(window));
+        }
+      } else if (!UsingBackingStoreSkia()) {
         // If the grey blend is showing, we make two drawing calls. Use double
         // buffering to prevent flicker. Use CairoShowRect because XShowRect
         // shortcuts GDK's double buffering.
         GdkRectangle rect = { paint_rect.x(), paint_rect.y(),
                               paint_rect.width(), paint_rect.height() };
         gdk_window_begin_paint_rect(window, &rect);
 
-        backing_store->CairoShowRect(paint_rect, GDK_DRAWABLE(window));
+        static_cast<BackingStoreX*>(backing_store)->CairoShowRect(
+            paint_rect, GDK_DRAWABLE(window));
 
         cairo_t* cr = gdk_cairo_create(window);
         gdk_cairo_rectangle(cr, &rect);
         cairo_set_source_rgba(cr, 0, 0, 0, 0.7);
         cairo_fill(cr);
         cairo_destroy(cr);
 
         gdk_window_end_paint(window);
+      } else {
+        // TODO(sad)
+        NOTIMPLEMENTED();
       }
     }
     if (!whiteout_start_time_.is_null()) {
       base::TimeDelta whiteout_duration = base::TimeTicks::Now() -
           whiteout_start_time_;
       UMA_HISTOGRAM_TIMES("MPArch.RWHH_WhiteoutDuration", whiteout_duration);
 
       // Reset the start time to 0 so that we start recording again the next
       // time the backing store is NULL...
       whiteout_start_time_ = base::TimeTicks();
@@ skipping 340 matching lines @@
 }
 
 // static
 RenderWidgetHostView*
     RenderWidgetHostView::GetRenderWidgetHostViewFromNativeView(
         gfx::NativeView widget) {
   gpointer user_data = g_object_get_data(G_OBJECT(widget),
                                          kRenderWidgetHostViewKey);
   return reinterpret_cast<RenderWidgetHostView*>(user_data);
 }