Temporarily re-enabling SizeAfterPrefChange test with traces

chrome/browser/extensions/extension_toolbar_model.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/extensions/extension_toolbar_model.h"
 
 #include <string>
 
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_base.h"
@@ skipping 140 matching lines @@
       *popup_url_out = browser_action->GetPopupUrl(tab_id);
     return ACTION_SHOW_POPUP;
   }
 
   ExtensionActionAPI::BrowserActionExecuted(
       browser->profile(), *browser_action, web_contents);
   return ACTION_NONE;
 }
 
 void ExtensionToolbarModel::SetVisibleIconCount(int count) {
-  LOG(ERROR) << "visible_icon_count_ before: " << visible_icon_count_;
+  VLOG(4) << "visible_icon_count_ before: " << visible_icon_count_;
   visible_icon_count_ =
       count == static_cast<int>(toolbar_items_.size()) ? -1 : count;
-  LOG(ERROR) << "SetVisibleIconCount "
-             << count << " == " << toolbar_items_.size() << " -> "
-             << visible_icon_count_ << " "
-             << "is_highlighting: " << is_highlighting_;
+  VLOG(4) << "SetVisibleIconCount "
+          << count << " == " << toolbar_items_.size() << " -> "
+          << visible_icon_count_ << " "
+          << "is_highlighting: " << is_highlighting_;
   // Only set the prefs if we're not in highlight mode. Highlight mode is
   // designed to be a transitory state, and should not persist across browser
   // restarts (though it may be re-entered).
   if (!is_highlighting_) {
     prefs_->SetInteger(pref_names::kToolbarSize, visible_icon_count_);
   }
 }
 
 void ExtensionToolbarModel::OnExtensionLoaded(
     content::BrowserContext* browser_context,
     const Extension* extension) {
-  LOG(ERROR) << "Loading extension";
+  VLOG(4) << "Loading extension";
 
   // We don't want to add the same extension twice. It may have already been
   // added by EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED below, if the user
   // hides the browser action and then disables and enables the extension.
   for (size_t i = 0; i < toolbar_items_.size(); i++) {
     if (toolbar_items_[i].get() == extension) {
-      LOG(ERROR) << "... but returning early";
+      VLOG(4) << "... but returning early";
       return;
     }
   }
   if (ExtensionActionAPI::GetBrowserActionVisibility(extension_prefs_,
                                                      extension->id())) {
-    LOG(ERROR) << "Adding extensions";
+    VLOG(4) << "Adding extensions";
     AddExtension(extension);
   } else {
-    LOG(ERROR) << "NOT visible";
+    VLOG(4) << "NOT visible";
   }
 }
 
 void ExtensionToolbarModel::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const Extension* extension,
     UnloadedExtensionInfo::Reason reason) {
   RemoveExtension(extension);
 }
 
@@ skipping 17 matching lines @@
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED,
             type);
   const Extension* extension =
       ExtensionRegistry::Get(profile_)->GetExtensionById(
           *content::Details<const std::string>(details).ptr(),
           ExtensionRegistry::EVERYTHING);
   if (ExtensionActionAPI::GetBrowserActionVisibility(extension_prefs_,
                                                      extension->id())) {
-    LOG(ERROR) << "Adding extension";
+    VLOG(4) << "Adding extension";
     AddExtension(extension);
   } else {
-    LOG(ERROR) << "Removing extension";
+    VLOG(4) << "Removing extension";
     RemoveExtension(extension);
   }
 }
 
 void ExtensionToolbarModel::OnReady() {
+  VLOG(4) << "OnReady called";
   ExtensionRegistry* registry = ExtensionRegistry::Get(profile_);
   InitializeExtensionList(registry->enabled_extensions());
   // Wait until the extension system is ready before observing any further
   // changes so that the toolbar buttons can be shown in their stable ordering
   // taken from prefs.
   extension_registry_observer_.Add(registry);
   registrar_.Add(
       this,
       chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED,
       content::Source<ExtensionPrefs>(extension_prefs_));
@@ skipping 93 matching lines @@
 // pref service. For robustness we use a somewhat inefficient process:
 // 1. Create a vector of extensions sorted by their pref values. This vector may
 // have holes.
 // 2. Create a vector of extensions that did not have a pref value.
 // 3. Remove holes from the sorted vector and append the unsorted vector.
 void ExtensionToolbarModel::InitializeExtensionList(
     const ExtensionSet& extensions) {
   last_known_positions_ = extension_prefs_->GetToolbarOrder();
   Populate(last_known_positions_, extensions);
 
+  VLOG(4) << "extensions_initialized!";
   extensions_initialized_ = true;
   FOR_EACH_OBSERVER(Observer, observers_, VisibleCountChanged());
 }
 
 void ExtensionToolbarModel::Populate(const ExtensionIdList& positions,
                                      const ExtensionSet& extensions) {
   // Items that have explicit positions.
   ExtensionList sorted;
   sorted.resize(positions.size(), NULL);
   // The items that don't have explicit positions.
@@ skipping 233 matching lines @@
     is_highlighting_ = false;
     if (old_visible_icon_count_ != visible_icon_count_) {
       SetVisibleIconCount(old_visible_icon_count_);
       FOR_EACH_OBSERVER(Observer, observers_, VisibleCountChanged());
     }
     FOR_EACH_OBSERVER(Observer, observers_, HighlightModeChanged(false));
   }
 }
 
 }  // namespace extensions