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 1183 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;
+      (host_desktop_type == chrome::HOST_DESKTOP_TYPE_ASH)
+          ? kInactiveTabAndNewTabButtonAlphaAsh
+          : kInactiveTabAndNewTabButtonAlpha;

[Peter Kasting, 2015/04/07 21:32:39]

It would have been nice not to reformat this or the one below, since they were
legal as-is...

[danakj, 2015/04/07 21:36:26]

git cl format did it, cuz I touched them, but I then undid my changes. I can
revert it. They'll just get reformatted the next time someone touches them
instead.

 
-  if (inactive_tab_alpha < 255)
-    canvas->SaveLayerAlpha(inactive_tab_alpha);
+  {
+    ui::CompositingRecorder opacity_recorder(context, inactive_tab_alpha);

[danakj, 2015/04/07 20:51:43]

This looks like a big change but it's mostly just re-indenting. I'll point out
what I've done:

This is a scoped CompositingRecorder instead of SaveLayerAlpha()/Restore()
calls.

 
-  PaintClosingTabs(tab_count(), context);
+    PaintClosingTabs(tab_count(), context);

[danakj, 2015/04/07 20:51:43]

This is all just reformatting...

 
-  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();

[danakj, 2015/04/07 20:51:43]

This goes away thanks to scoped recorder.

-
   if (GetWidget()->ShouldWindowContentsBeTransparent()) {
+    ui::PaintRecorder recorder(context);

[danakj, 2015/04/07 20:51:43]

A paint recorder to draw to a canvas

     // 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;
+    int 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);

[danakj, 2015/04/07 20:51:43]

Another scoped recorder for 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;
 }