[WIP] Fire a theme changed notification when device scan completes

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"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 234 matching lines @@
 }
 
 TabDragController::EventSource EventSourceFromEvent(
     const ui::LocatedEvent& event) {
   return event.IsGestureEvent() ? TabDragController::EVENT_SOURCE_TOUCH :
       TabDragController::EVENT_SOURCE_MOUSE;
 }
 
 const TabSizeInfo& GetTabSizeInfo() {
   static TabSizeInfo* tab_size_info = nullptr;
-  if (tab_size_info)
-    return *tab_size_info;
+
+//  if (tab_size_info)
+//    return *tab_size_info;

[tdanderson, 2016/05/02 18:55:44]

Turns out the source of the incorrect drawing was that the TabSizeInfo is cached
when defaulting to 'material' and not recalculated when the device scan
completes and we switch to hybrid. How would you feel about either:

a) never caching this at all, or
b) keeping track of the MD mode we were using when we cached, then recalculating
if the mode is different when GetTabSizeInfo() is called?

 
   tab_size_info = new TabSizeInfo;
   tab_size_info->pinned_tab_width = Tab::GetPinnedWidth();
   tab_size_info->min_active_width = Tab::GetMinimumActiveSize().width();
   tab_size_info->min_inactive_width = Tab::GetMinimumInactiveSize().width();
   tab_size_info->max_size = Tab::GetStandardSize();
   tab_size_info->tab_overlap = GetLayoutConstant(TABSTRIP_TAB_OVERLAP);
   tab_size_info->pinned_to_normal_offset = kPinnedToNonPinnedOffset;
   return *tab_size_info;
 }
@@ skipping 1438 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, private:
 
 void TabStrip::Init() {
   set_id(VIEW_ID_TAB_STRIP);
   // So we get enter/exit on children to switch stacked layout on and off.
   set_notify_enter_exit_on_child(true);
 
-  newtab_button_bounds_.set_size(GetLayoutSize(NEW_TAB_BUTTON));
-  newtab_button_bounds_.Inset(0, 0, 0, -GetNewTabButtonTopOffset());
+  CalculateNewTabButtonSize();
   newtab_button_ = new NewTabButton(this, this);
   newtab_button_->SetTooltipText(
       l10n_util::GetStringUTF16(IDS_TOOLTIP_NEW_TAB));
   newtab_button_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_ACCNAME_NEWTAB));
   newtab_button_->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
                                     views::ImageButton::ALIGN_BOTTOM);
   newtab_button_->SetEventTargeter(std::unique_ptr<views::ViewTargeter>(
       new views::ViewTargeter(newtab_button_)));
   AddChildView(newtab_button_);
@@ skipping 774 matching lines @@
     const std::vector<gfx::Rect> tabs_bounds =
         CalculateBounds(GetTabSizeInfo(), GetPinnedTabCount(), tab_count(),
                         controller_->GetActiveIndex(), available_width,
                         &current_active_width_, &current_inactive_width_);
     DCHECK_EQ(static_cast<size_t>(tab_count()), tabs_bounds.size());
 
     for (size_t i = 0; i < tabs_bounds.size(); ++i)
       tabs_.set_ideal_bounds(i, tabs_bounds[i]);
   }
 
+  CalculateNewTabButtonSize();

[tdanderson, 2016/05/02 18:55:44]

Same problem: the new tab button dimensions are calculated initially for
'material' and are never re-calculated when we switch to hybrid.

   const int max_new_tab_x = width() - newtab_button_bounds_.width();
   // For non-stacked tabs the ideal bounds may go outside the bounds of the
   // tabstrip. Constrain the x-coordinate of the new tab button so that it is
   // always visible.
   const int new_tab_x = std::min(
       max_new_tab_x, tabs_.ideal_bounds(tabs_.view_size() - 1).right() -
                          GetLayoutConstant(TABSTRIP_NEW_TAB_BUTTON_OVERLAP));
   const int old_max_x = newtab_button_bounds_.right();
   newtab_button_bounds_.set_origin(gfx::Point(new_tab_x, 0));
   if (newtab_button_bounds_.right() != old_max_x)
     FOR_EACH_OBSERVER(TabStripObserver, observers_, TabStripMaxXChanged(this));
 }
 
+void TabStrip::CalculateNewTabButtonSize() {
+  newtab_button_bounds_.set_size(GetLayoutSize(NEW_TAB_BUTTON));
+  newtab_button_bounds_.Inset(0, 0, 0, -GetNewTabButtonTopOffset());
+}
+
 int TabStrip::GenerateIdealBoundsForPinnedTabs(int* first_non_pinned_index) {
   const int num_pinned_tabs = GetPinnedTabCount();
 
   if (first_non_pinned_index)
     *first_non_pinned_index = num_pinned_tabs;
 
   if (num_pinned_tabs == 0)
     return 0;
 
   std::vector<gfx::Rect> tab_bounds(tab_count());
@@ skipping 357 matching lines @@
           ConvertPointToViewAndGetEventHandler(this, newtab_button_, point);
       if (view)
         return view;
     }
     Tab* tab = FindTabForEvent(point);
     if (tab)
       return ConvertPointToViewAndGetEventHandler(this, tab, point);
   }
   return this;
 }