tabstrip: Use a PaintRecorder to access the Canvas for painting.

chrome/browser/ui/views/tabs/tab_strip.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 "chrome/browser/ui/views/tabs/tab_strip.h"
 
 #if defined(OS_WIN)
 #include <windowsx.h>
 #endif
 
@@ skipping 20 matching lines @@
 #include "chrome/common/chrome_switches.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/user_metrics.h"
 #include "grit/theme_resources.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/default_theme_provider.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/list_selection_model.h"
 #include "ui/base/resource/resource_bundle.h"
-#include "ui/compositor/paint_context.h"
+#include "ui/compositor/compositing_recorder.h"
+#include "ui/compositor/paint_recorder.h"
 #include "ui/gfx/animation/animation_container.h"
 #include "ui/gfx/animation/throb_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/screen.h"
@@ skipping 15 matching lines @@
 #include "ui/views/win/hwnd_util.h"
 #endif
 
 using base::UserMetricsAction;
 using ui::DropTargetEvent;
 
 namespace {
 
 static const int kTabStripAnimationVSlop = 40;
 // Inactive tabs in a native frame are slightly transparent.
-static const int kGlassFrameInactiveTabAlpha = 200;
+static const uint8_t kGlassFrameInactiveTabAlpha = 200;
 // If there are multiple tabs selected then make non-selected inactive tabs
 // even more transparent.
 static const int kGlassFrameInactiveTabAlphaMultiSelection = 150;
 
 // Alpha applied to all elements save the selected tabs.
-static const int kInactiveTabAndNewTabButtonAlphaAsh = 230;
-static const int kInactiveTabAndNewTabButtonAlpha = 255;
+static const uint8_t kInactiveTabAndNewTabButtonAlphaAsh = 230;
+static const uint8_t kInactiveTabAndNewTabButtonAlpha = 255;
 
 // Inverse ratio of the width of a tab edge to the width of the tab. When
 // hovering over the left or right edge of a tab, the drop indicator will
 // point between tabs.
 static const int kTabEdgeRatioInverse = 4;
 
 // Size of the drop indicator.
 static int drop_indicator_width;
 static int drop_indicator_height;
 
@@ skipping 356 matching lines @@
         IDR_NEWTAB_BUTTON_P : IDR_NEWTAB_BUTTON;
   gfx::ImageSkia* overlay = GetThemeProvider()->GetImageSkiaNamed(overlay_id);
 
   gfx::Canvas canvas(
       gfx::Size(overlay->width(), overlay->height()),
       scale,
       false);
   canvas.DrawImageInt(GetBackgroundImage(state, scale), 0, 0);
 
   // Draw the button border with a slight alpha.
-  const int kGlassFrameOverlayAlpha = 178;
-  const int kOpaqueFrameOverlayAlpha = 230;
-  uint8 alpha = ShouldWindowContentsBeTransparent() ?
-      kGlassFrameOverlayAlpha : kOpaqueFrameOverlayAlpha;
+  const uint8_t kGlassFrameOverlayAlpha = 178;
+  const uint8_t kOpaqueFrameOverlayAlpha = 230;
+  uint8_t alpha = ShouldWindowContentsBeTransparent()
+                      ? kGlassFrameOverlayAlpha
+                      : kOpaqueFrameOverlayAlpha;
   canvas.DrawImageInt(*overlay, 0, 0, alpha);
 
   return gfx::ImageSkia(canvas.ExtractImageRep());
 }
 
 gfx::ImageSkia NewTabButton::GetImageForScale(float scale) const {
   if (!hover_animation_->is_animating())
     return GetImageForState(state(), scale);
   return gfx::ImageSkiaOperations::CreateBlendedImage(
       GetImageForState(views::CustomButton::STATE_NORMAL, scale),
@@ skipping 760 matching lines @@
 void TabStrip::Layout() {
   // Only do a layout if our size changed.
   if (last_layout_size_ == size())
     return;
   if (IsDragSessionActive())
     return;
   DoLayout();
 }
 
 void TabStrip::PaintChildren(const ui::PaintContext& context) {
-  gfx::Canvas* canvas = context.canvas();
   // The view order doesn't match the paint order (tabs_ contains the tab
   // ordering). Additionally we need to paint the tabs that are closing in
   // |tabs_closing_map_|.
   Tab* active_tab = NULL;
   Tabs tabs_dragging;
   Tabs selected_tabs;
   int selected_tab_count = 0;
   bool is_dragging = false;
   int active_tab_index = -1;
 
   const chrome::HostDesktopType host_desktop_type =
       chrome::GetHostDesktopTypeForNativeView(GetWidget()->GetNativeView());
-  const int inactive_tab_alpha =
-      (host_desktop_type == chrome::HOST_DESKTOP_TYPE_ASH) ?
-      kInactiveTabAndNewTabButtonAlphaAsh : kInactiveTabAndNewTabButtonAlpha;
+  const uint8_t inactive_tab_alpha =
+      (host_desktop_type == chrome::HOST_DESKTOP_TYPE_ASH)
+          ? kInactiveTabAndNewTabButtonAlphaAsh
+          : kInactiveTabAndNewTabButtonAlpha;
 
-  if (inactive_tab_alpha < 255)
-    canvas->SaveLayerAlpha(inactive_tab_alpha);
+  {
+    ui::CompositingRecorder opacity_recorder(context, inactive_tab_alpha);
 
-  PaintClosingTabs(tab_count(), context);
+    PaintClosingTabs(tab_count(), context);
 
-  for (int i = tab_count() - 1; i >= 0; --i) {
-    Tab* tab = tab_at(i);
-    if (tab->IsSelected())
-      selected_tab_count++;
-    if (tab->dragging() && !stacked_layout_) {
-      is_dragging = true;
-      if (tab->IsActive()) {
+    for (int i = tab_count() - 1; i >= 0; --i) {
+      Tab* tab = tab_at(i);
+      if (tab->IsSelected())
+        selected_tab_count++;
+      if (tab->dragging() && !stacked_layout_) {
+        is_dragging = true;
+        if (tab->IsActive()) {
+          active_tab = tab;
+          active_tab_index = i;
+        } else {
+          tabs_dragging.push_back(tab);
+        }
+      } else if (!tab->IsActive()) {
+        if (!tab->IsSelected()) {
+          if (!stacked_layout_)
+            tab->Paint(context);
+        } else {
+          selected_tabs.push_back(tab);
+        }
+      } else {
         active_tab = tab;
         active_tab_index = i;
-      } else {
-        tabs_dragging.push_back(tab);
       }
-    } else if (!tab->IsActive()) {
-      if (!tab->IsSelected()) {
-        if (!stacked_layout_)
-          tab->Paint(context);
-      } else {
-        selected_tabs.push_back(tab);
+      PaintClosingTabs(i, context);
+    }
+
+    // Draw from the left and then the right if we're in touch mode.
+    if (stacked_layout_ && active_tab_index >= 0) {
+      for (int i = 0; i < active_tab_index; ++i) {
+        Tab* tab = tab_at(i);
+        tab->Paint(context);
       }
-    } else {
-      active_tab = tab;
-      active_tab_index = i;
+
+      for (int i = tab_count() - 1; i > active_tab_index; --i) {
+        Tab* tab = tab_at(i);
+        tab->Paint(context);
+      }
     }
-    PaintClosingTabs(i, context);
   }
 
-  // Draw from the left and then the right if we're in touch mode.
-  if (stacked_layout_ && active_tab_index >= 0) {
-    for (int i = 0; i < active_tab_index; ++i) {
-      Tab* tab = tab_at(i);
-      tab->Paint(context);
-    }
-
-    for (int i = tab_count() - 1; i > active_tab_index; --i) {
-      Tab* tab = tab_at(i);
-      tab->Paint(context);
-    }
-  }
-  if (inactive_tab_alpha < 255)
-    canvas->Restore();
-
   if (GetWidget()->ShouldWindowContentsBeTransparent()) {
+    ui::PaintRecorder recorder(context);
     // Make sure non-active tabs are somewhat transparent.
     SkPaint paint;
     // If there are multiple tabs selected, fade non-selected tabs more to make
     // the selected tabs more noticable.
-    int alpha = selected_tab_count > 1 ?
-        kGlassFrameInactiveTabAlphaMultiSelection :
-        kGlassFrameInactiveTabAlpha;
+    uint8_t alpha = selected_tab_count > 1
+                        ? kGlassFrameInactiveTabAlphaMultiSelection
+                        : kGlassFrameInactiveTabAlpha;
     paint.setColor(SkColorSetARGB(alpha, 255, 255, 255));
     paint.setXfermodeMode(SkXfermode::kDstIn_Mode);
     paint.setStyle(SkPaint::kFill_Style);
 
     // The tab graphics include some shadows at the top, so the actual
     // tabstrip top is 4 px. above the apparent top of the tab, to provide room
     // to draw these. Exclude this region when trying to make tabs transparent
     // as it's transparent enough already, and drawing in this region can
     // overlap the avatar button, leading to visual artifacts.
     const int kTopOffset = 4;
     // The tabstrip area overlaps the toolbar area by 2 px.
-    canvas->DrawRect(
+    recorder.canvas()->DrawRect(
         gfx::Rect(0, kTopOffset, width(), height() - kTopOffset - 2), paint);
   }
 
   // Now selected but not active. We don't want these dimmed if using native
   // frame, so they're painted after initial pass.
   for (size_t i = 0; i < selected_tabs.size(); ++i)
     selected_tabs[i]->Paint(context);
 
   // Next comes the active tab.
   if (active_tab && !is_dragging)
     active_tab->Paint(context);
 
   // Paint the New Tab button.
-  if (inactive_tab_alpha < 255)
-    canvas->SaveLayerAlpha(inactive_tab_alpha);
-  newtab_button_->Paint(context);
-  if (inactive_tab_alpha < 255)
-    canvas->Restore();
+  {
+    ui::CompositingRecorder opacity_recorder(context, inactive_tab_alpha);
+    newtab_button_->Paint(context);
+  }
 
   // And the dragged tabs.
   for (size_t i = 0; i < tabs_dragging.size(); ++i)
     tabs_dragging[i]->Paint(context);
 
   // If the active tab is being dragged, it goes last.
   if (active_tab && is_dragging)
     active_tab->Paint(context);
 }
 
@@ skipping 1402 matching lines @@
           ConvertPointToViewAndGetEventHandler(this, newtab_button_, point);
       if (view)
         return view;
     }
     Tab* tab = FindTabForEvent(point);
     if (tab)
       return ConvertPointToViewAndGetEventHandler(this, tab, point);
   }
   return this;
 }