add mole info to toolstrip definition and enable moles

chrome/browser/extensions/extension_shelf_model.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/extensions/extension_shelf_model.h"
 
 #include "base/stl_util-inl.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/extensions/extension_host.h"
@@ skipping 24 matching lines @@
       AddExtensions(service->extensions());
       SortToolstrips();
     }
   }
 }
 
 ExtensionShelfModel::~ExtensionShelfModel() {
   while (observers_.size())
     observers_.RemoveObserver(observers_.GetElementAt(0));
 
-  STLDeleteContainerPairFirstPointers(toolstrips_.begin(), toolstrips_.end());
+  ExtensionToolstrips::iterator t;
+  for (t = toolstrips_.begin(); t != toolstrips_.end(); ++t)
+    delete t->host;
   toolstrips_.clear();
 }
 
 void ExtensionShelfModel::AddObserver(ExtensionShelfModelObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void ExtensionShelfModel::RemoveObserver(
     ExtensionShelfModelObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void ExtensionShelfModel::AppendToolstrip(ExtensionHost* toolstrip) {
-  InsertToolstripAt(count(), toolstrip, NULL);
+void ExtensionShelfModel::AppendToolstrip(const ToolstripItem& toolstrip) {
+  InsertToolstripAt(count(), toolstrip);
 }
 
 void ExtensionShelfModel::InsertToolstripAt(int index,
-                                            ExtensionHost* toolstrip,
-                                            void* data) {
-  toolstrips_.insert(toolstrips_.begin() + index,
-                     ToolstripItem(toolstrip, data));
+                                            const ToolstripItem& toolstrip) {
+  toolstrips_.insert(toolstrips_.begin() + index, toolstrip);
   if (ready_) {
     FOR_EACH_OBSERVER(ExtensionShelfModelObserver, observers_,
-                      ToolstripInsertedAt(toolstrip, index));
+                      ToolstripInsertedAt(toolstrip.host, index));
   }
 }
 
 void ExtensionShelfModel::RemoveToolstripAt(int index) {
-  ExtensionHost* toolstrip = ToolstripAt(index);
+  ExtensionHost* host = ToolstripAt(index);
   FOR_EACH_OBSERVER(ExtensionShelfModelObserver, observers_,
-                    ToolstripRemovingAt(toolstrip, index));
+                    ToolstripRemovingAt(host, index));
   toolstrips_.erase(toolstrips_.begin() + index);
-  delete toolstrip;
+  delete host;
 }
 
 void ExtensionShelfModel::MoveToolstripAt(int index, int to_index) {
   DCHECK(index >= 0);
   DCHECK(to_index >= 0);
   if (index == to_index)
     return;
 
   ToolstripItem toolstrip = toolstrips_[index];
   toolstrips_.erase(toolstrips_.begin() + index);
   toolstrips_.insert(toolstrips_.begin() + to_index, toolstrip);
 
   FOR_EACH_OBSERVER(ExtensionShelfModelObserver, observers_,
-                    ToolstripMoved(toolstrip.first, index, to_index));
+                    ToolstripMoved(toolstrip.host, index, to_index));
 
   UpdatePrefs();
 }
 
 int ExtensionShelfModel::IndexOfToolstrip(ExtensionHost* toolstrip) {
   ExtensionToolstrips::iterator i;
   for (i = toolstrips_.begin(); i != toolstrips_.end(); ++i) {
-    if (i->first == toolstrip)
+    if (i->host == toolstrip)
       return i - toolstrips_.begin();
   }
   return -1;
 }
 
 ExtensionHost* ExtensionShelfModel::ToolstripAt(int index) {
   DCHECK(index >= 0);
-  return toolstrips_[index].first;
+  return toolstrips_[index].host;
+}
+
+Extension::ToolstripInfo* ExtensionShelfModel::ToolstripInfoAt(int index) {
+  DCHECK(index >= 0);
+  return &(toolstrips_[index].info);
 }
 
 void* ExtensionShelfModel::ToolstripDataAt(int index) {
   DCHECK(index >= 0);
-  return toolstrips_[index].second;
+  return toolstrips_[index].data;
 }
 
 void ExtensionShelfModel::SetToolstripDataAt(int index, void* data) {
   DCHECK(index >= 0);
-  toolstrips_[index].second = data;
+  toolstrips_[index].data = data;
 }
 
 void ExtensionShelfModel::Observe(NotificationType type,
                                   const NotificationSource& source,
                                   const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::EXTENSIONS_LOADED:
       if (ready_)
         AddExtensions(Details<ExtensionList>(details).ptr());
       break;
@@ skipping 18 matching lines @@
   }
 }
 
 void ExtensionShelfModel::AddExtension(Extension* extension) {
   ExtensionProcessManager* manager =
       browser_->profile()->GetExtensionProcessManager();
   DCHECK(manager);
   if (!manager)
     return;
 
-  for (std::vector<std::string>::const_iterator toolstrip_path =
+  for (std::vector<Extension::ToolstripInfo>::const_iterator toolstrip =
        extension->toolstrips().begin();
-       toolstrip_path != extension->toolstrips().end(); ++toolstrip_path) {
-    GURL url = extension->GetResourceURL(*toolstrip_path);
-    ExtensionHost* host = manager->CreateView(extension, url, browser_);
-    AppendToolstrip(host);
+       toolstrip != extension->toolstrips().end(); ++toolstrip) {
+    GURL url = toolstrip->toolstrip;
+    ToolstripItem item;
+    item.host = manager->CreateView(extension, url, browser_);
+    item.info = *toolstrip;
+    item.data = NULL;
+    AppendToolstrip(item);
   }
 }
 
 void ExtensionShelfModel::AddExtensions(const ExtensionList* extensions) {
   if (extensions->size()) {
     ExtensionList::const_iterator extension = extensions->begin();
     for (; extension != extensions->end(); ++extension)
       AddExtension(*extension);
   }
 }
@@ skipping 35 matching lines @@
   ExtensionToolstrips copy =
       ExtensionToolstrips(toolstrips_.begin(), toolstrips_.end());
   toolstrips_.clear();
 
   // Go through the urls and find the matching toolstrip, re-adding it to the
   // new list in the proper order.
   for (size_t i = 0; i < urls.size(); ++i) {
     GURL& url = urls[i];
     for (ExtensionToolstrips::iterator toolstrip = copy.begin();
         toolstrip != copy.end(); ++toolstrip) {
-      if (url == (*toolstrip).first->GetURL()) {
+      if (url == toolstrip->host->GetURL()) {
         // Note that it's technically possible for the same URL to appear in
         // multiple toolstrips, so we don't do any testing for uniqueness.
         toolstrips_.push_back(*toolstrip);
 
         // Remove the toolstrip from the list so we don't have to iterate over
         // it next time.
         copy.erase(toolstrip);
         break;
       }
     }
   }
 
   // Any toolstrips remaining in |copy| were somehow missing from the prefs,
   // so just append them to the end.
   for (ExtensionToolstrips::iterator toolstrip = copy.begin();
       toolstrip != copy.end(); ++toolstrip) {
     toolstrips_.push_back(*toolstrip);
   }
 
   FOR_EACH_OBSERVER(ExtensionShelfModelObserver, observers_,
                     ShelfModelReloaded());
 }