Fix extension toolstrip background update code

chrome/browser/views/extensions/extension_shelf.cc

 // Copyright (c) 2009 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/views/extensions/extension_shelf.h"
 
 #include <algorithm>
 
 #include "app/resource_bundle.h"
 #include "base/logging.h"
@@ skipping 462 matching lines @@
 void ExtensionShelf::Toolstrip::AnimationEnded(const Animation* animation) {
   LayoutHandle();
   if (!expanded_) {
     // Must use the delay due to bug 18248.
     HideShelfHandle(kHideDelayMs * 2);
     AttachToShelf(false);
   }
 }
 
 int ExtensionShelf::Toolstrip::GetVerticalTearFromShelfThreshold() {
-  // TODO (sidchat): Compute this value from the toolstrip height.
+  // TODO(sidchat): Compute this value from the toolstrip height.
   return 29;
 }
 
 void ExtensionShelf::Toolstrip::DetachFromShelf(bool browserDetach) {
   DCHECK(handle_.get());
   DCHECK(!placeholder_view_);
   if (browserDetach && handle_->attached())
     handle_->DetachFromBrowser();
 
   // Construct a placeholder view to replace the view.
@@ skipping 131 matching lines @@
         delay_ms);
   } else {
     DoHideShelfHandle();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 ExtensionShelf::ExtensionShelf(Browser* browser)
   :   background_needs_repaint_(true),
-      background_for_detached_(false),
       browser_(browser),
       model_(browser->extension_shelf_model()) {
   model_->AddObserver(this);
   LoadFromModel();
   EnableCanvasFlippingForRTLUI(true);
   registrar_.Add(this,
                  NotificationType::EXTENSION_SHELF_VISIBILITY_PREF_CHANGED,
                  NotificationService::AllSources());
 
   size_animation_.reset(new SlideAnimation(this));
   if (IsAlwaysShown())
     size_animation_->Reset(1);
   else
     size_animation_->Reset(0);
 }
 
 ExtensionShelf::~ExtensionShelf() {
   if (model_) {
     int count = model_->count();
     for (int i = 0; i < count; ++i) {
       delete ToolstripAtIndex(i);
       model_->SetToolstripDataAt(i, NULL);
     }
     model_->RemoveObserver(this);
   }
 }
 
 void ExtensionShelf::PaintChildren(gfx::Canvas* canvas) {
-  // Capture a background bitmap to give to the toolstrips.
-  SkRect background_rect = {
-      SkIntToScalar(0),
-      SkIntToScalar(0),
-      SkIntToScalar(width()),
-      SkIntToScalar(height())
-  };
-  InitBackground(canvas, background_rect);
+  InitBackground(canvas);
 
   // Draw vertical dividers between Toolstrip items in the Extension shelf.
   int count = GetChildViewCount();
   for (int i = 0; i < count; ++i) {
     int right = GetChildViewAt(i)->bounds().right() + kToolstripPadding;
     int vertical_padding = IsDetached() ? (height() - kShelfHeight) / 2 : 1;
 
     DetachableToolbarView::PaintVerticalDivider(
         canvas, right, height(), vertical_padding,
         DetachableToolbarView::kEdgeDividerColor,
@@ skipping 57 matching lines @@
     return true;
   }
   return false;
 }
 
 void ExtensionShelf::SetAccessibleName(const std::wstring& name) {
   accessible_name_.assign(name);
 }
 
 void ExtensionShelf::ThemeChanged() {
-  background_needs_repaint_ = true;
-
   // Refresh the CSS to update toolstrip text colors from theme.
   int count = model_->count();
   for (int i = 0; i < count; ++i)
     ToolstripAtIndex(i)->view()->host()->InsertCssIfToolstrip();
 
   Layout();
 }
 
 void ExtensionShelf::ToolstripInsertedAt(ExtensionHost* host,
                                          int index) {
   model_->SetToolstripDataAt(index,
       new Toolstrip(this, host, model_->ToolstripAt(index).info));
 
   bool had_views = GetChildViewCount() > 0;
   ExtensionView* view = host->view();
-  background_needs_repaint_ = true;
   AddChildView(view);
   view->SetContainer(this);
   if (!had_views)
     PreferredSizeChanged();
   Layout();
 }
 
 void ExtensionShelf::ToolstripRemovingAt(ExtensionHost* host, int index) {
   // Delete the Toolstrip view and remove it from the model.
   Toolstrip* toolstrip = ToolstripAtIndex(index);
@@ skipping 48 matching lines @@
 
 void ExtensionShelf::AnimationProgressed(const Animation* animation) {
   if (browser_)
     browser_->ExtensionShelfSizeChanged();
 }
 
 void ExtensionShelf::AnimationEnded(const Animation* animation) {
   if (browser_)
     browser_->ExtensionShelfSizeChanged();
 
-  background_needs_repaint_ = true;
   Layout();
 }
 
 void ExtensionShelf::Observe(NotificationType type,
                              const NotificationSource& source,
                              const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::EXTENSION_SHELF_VISIBILITY_PREF_CHANGED: {
       if (IsAlwaysShown())
         size_animation_->Show();
@@ skipping 40 matching lines @@
                                      int height) {
   ExtensionShelfModel::iterator toolstrip = model_->ToolstripForHost(host);
   model_->ExpandToolstrip(toolstrip, url, height);
 }
 
 void ExtensionShelf::CollapseToolstrip(ExtensionHost* host, const GURL& url) {
   ExtensionShelfModel::iterator toolstrip = model_->ToolstripForHost(host);
   model_->CollapseToolstrip(toolstrip, url);
 }
 
-void ExtensionShelf::InitBackground(
-    gfx::Canvas* canvas, const SkRect& subset) {
-  bool detached = IsDetached();
-  if (!background_needs_repaint_ && background_for_detached_ == detached)
+void ExtensionShelf::InitBackground(gfx::Canvas* canvas) {
+  if (!background_needs_repaint_)
     return;
 
-  background_for_detached_ = detached;
+  // Capture a background bitmap to give to the toolstrips.
+  SkRect background_rect = {
+      SkIntToScalar(0),
+      SkIntToScalar(0),
+      SkIntToScalar(width()),
+      SkIntToScalar(height())
+  };
 
-  // Tell all extension views about the new background
+  // Tell all extension views about the new background.
   int count = model_->count();
   for (int i = 0; i < count; ++i) {
     ExtensionView* view = ToolstripAtIndex(i)->view();
 
     const SkBitmap& background = canvas->getDevice()->accessBitmap(false);
 
-    // Extract the correct subset of the toolstrip background into a bitmap. We
-    // must use a temporary here because extractSubset() returns a bitmap that
-    // references pixels in the original one and we want to actually make a copy
-    // that will have a long lifetime.
-    SkBitmap temp;
-    temp.setConfig(background.config(),
-                   static_cast<int>(subset.width()),
-                   static_cast<int>(subset.height()));
-
-    SkRect mapped_subset = subset;
+    SkRect mapped_subset = background_rect;
     gfx::Rect view_bounds = view->bounds();
     mapped_subset.offset(SkIntToScalar(view_bounds.x()),
                          SkIntToScalar(view_bounds.y()));
     bool result = canvas->getTotalMatrix().mapRect(&mapped_subset);
     DCHECK(result);
 
     SkIRect isubset;
     mapped_subset.round(&isubset);
-    result = background.extractSubset(&temp, isubset);
+    SkBitmap subset_bitmap;
+    // This will create another bitmap that just references pixels in the
+    // actual bitmap.
+    result = background.extractSubset(&subset_bitmap, isubset);
     if (!result)
       return;
 
-    DCHECK(temp.readyToDraw());
+    // We do a deep copy because extractSubset() returns a bitmap that
+    // references pixels in the original one and we want to actually make a
+    // smaller copy that will have a long lifetime.
+    SkBitmap smaller_copy;
+    if (!subset_bitmap.copyTo(&smaller_copy, SkBitmap::kARGB_8888_Config))
+      return;
+    DCHECK(smaller_copy.readyToDraw());
 
-    view->SetBackground(temp);
+    view->SetBackground(smaller_copy);
   }
 
   background_needs_repaint_ = false;
 }
 
 ExtensionShelf::Toolstrip* ExtensionShelf::ToolstripAtX(int x) {
   int count = model_->count();
   if (count == 0)
     return NULL;
 
@@ skipping 66 matching lines @@
       if (view == toolstrip->view())
         toolstrip->view()->set_is_clipped(next_x >= max_x);
       view->SetBounds(x, y, pref.width(), content_height);
       view->Layout();
       if (toolstrip->handle_visible())
         toolstrip->LayoutHandle();
     }
     x = next_x + kToolstripDividerWidth;
   }
 
-  if (!compute_bounds_only)
+  if (!compute_bounds_only) {
+    background_needs_repaint_ = true;
     SchedulePaint();
-
-  if (compute_bounds_only) {
+  } else {
     if (OnNewTabPage()) {
       prefsize.set_height(kShelfHeight + static_cast<int>(static_cast<double>
                               (kNewtabShelfHeight - kShelfHeight) *
                               (1 - size_animation_->GetCurrentValue())));
     } else {
       prefsize.set_height(static_cast<int>(static_cast<double>(kShelfHeight) *
                               size_animation_->GetCurrentValue()));
     }
 
     x += kRightMargin;
@@ skipping 15 matching lines @@
 
 bool ExtensionShelf::IsAlwaysShown() const {
   Profile* profile = browser_->profile();
   return profile->GetPrefs()->GetBoolean(prefs::kShowExtensionShelf);
 }
 
 bool ExtensionShelf::OnNewTabPage() const {
   return (browser_ && browser_->GetSelectedTabContents() &&
       browser_->GetSelectedTabContents()->IsExtensionShelfAlwaysVisible());
 }