Remove ExtensionToolbarModel from ExtensionService.

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/prefs/pref_service.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 #include "chrome/browser/extensions/extension_action.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
+#include "chrome/browser/extensions/extension_toolbar_model_factory.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/feature_switch.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
@@ skipping 15 matching lines @@
   return false;
 }
 
 }  // namespace
 
 bool ExtensionToolbarModel::Observer::BrowserActionShowPopup(
     const extensions::Extension* extension) {
   return false;
 }
 
-ExtensionToolbarModel::ExtensionToolbarModel(ExtensionService* service)
-    : service_(service),
-      prefs_(service->profile()->GetPrefs()),
+ExtensionToolbarModel::ExtensionToolbarModel(
+    Profile* profile,
+    extensions::ExtensionPrefs* extension_prefs)
+    : profile_(profile),
+      extension_prefs_(extension_prefs),
+      prefs_(profile_->GetPrefs()),
       extensions_initialized_(false),
       weak_ptr_factory_(this) {
-  DCHECK(service_);
-
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
-                 content::Source<Profile>(service_->profile()));
+                 content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
-                 content::Source<Profile>(service_->profile()));
+                 content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSIONS_READY,
-                 content::Source<Profile>(service_->profile()));
+                 content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNINSTALLED,
-                 content::Source<Profile>(service_->profile()));
+                 content::Source<Profile>(profile_));
   registrar_.Add(
       this, chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED,
-      content::Source<extensions::ExtensionPrefs>(service_->extension_prefs()));
+      content::Source<extensions::ExtensionPrefs>(extension_prefs_));
 
   visible_icon_count_ = prefs_->GetInteger(prefs::kExtensionToolbarSize);
 
   pref_change_registrar_.Init(prefs_);
   pref_change_callback_ =
       base::Bind(&ExtensionToolbarModel::OnExtensionToolbarPrefChange,
                  base::Unretained(this));
   pref_change_registrar_.Add(prefs::kExtensionToolbar, pref_change_callback_);
 }
 
 ExtensionToolbarModel::~ExtensionToolbarModel() {
 }
 
+// static
+ExtensionToolbarModel* ExtensionToolbarModel::Get(Profile* profile) {
+  return ExtensionToolbarModelFactory::GetForProfile(profile);
+}
+
 void ExtensionToolbarModel::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void ExtensionToolbarModel::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void ExtensionToolbarModel::MoveBrowserAction(const Extension* extension,
                                               int index) {
@@ skipping 44 matching lines @@
     const Extension* extension,
     Browser* browser,
     GURL* popup_url_out,
     bool should_grant) {
   content::WebContents* web_contents = NULL;
   int tab_id = 0;
   if (!ExtensionTabUtil::GetDefaultTab(browser, &web_contents, &tab_id))
     return ACTION_NONE;
 
   ExtensionAction* browser_action =
-      extensions::ExtensionActionManager::Get(service_->profile())->
+      extensions::ExtensionActionManager::Get(profile_)->
       GetBrowserAction(*extension);
 
   // For browser actions, visibility == enabledness.
   if (!browser_action->GetIsVisible(tab_id))
     return ACTION_NONE;
 
   if (should_grant) {
     extensions::TabHelper::FromWebContents(web_contents)->
         active_tab_permission_granter()->GrantIfRequested(extension);
   }
@@ skipping 12 matching lines @@
 void ExtensionToolbarModel::SetVisibleIconCount(int count) {
   visible_icon_count_ =
       count == static_cast<int>(toolbar_items_.size()) ? -1 : count;
   prefs_->SetInteger(prefs::kExtensionToolbarSize, visible_icon_count_);
 }
 
 void ExtensionToolbarModel::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
+  ExtensionService* extension_service =
+      extensions::ExtensionSystem::Get(profile_)->extension_service();
+  if (!extension_service || !extension_service->is_ready())
+    return;
+
   if (type == chrome::NOTIFICATION_EXTENSIONS_READY) {
-    InitializeExtensionList();
+    InitializeExtensionList(extension_service);
     return;
   }
 
-  if (!service_->is_ready())
-    return;
-
   const Extension* extension = NULL;
   if (type == chrome::NOTIFICATION_EXTENSION_UNLOADED) {
     extension = content::Details<extensions::UnloadedExtensionInfo>(
         details)->extension;
   } else if (type ==
       chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED) {
-    extension = service_->GetExtensionById(
+    extension = extension_service->GetExtensionById(
         *content::Details<const std::string>(details).ptr(), true);
   } else {
     extension = content::Details<const Extension>(details).ptr();
   }
   if (type == chrome::NOTIFICATION_EXTENSION_LOADED) {
     // 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)
         return;  // Already exists.
     }
     if (extensions::ExtensionActionAPI::GetBrowserActionVisibility(
-            service_->extension_prefs(), extension->id())) {
+            extension_prefs_, extension->id())) {
       AddExtension(extension);
     }
   } else if (type == chrome::NOTIFICATION_EXTENSION_UNLOADED) {
     RemoveExtension(extension);
   } else if (type == chrome::NOTIFICATION_EXTENSION_UNINSTALLED) {
     UninstalledExtension(extension);
   } else if (type ==
       chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED) {
     if (extensions::ExtensionActionAPI::GetBrowserActionVisibility(
-            service_->extension_prefs(), extension->id())) {
+            extension_prefs_, extension->id())) {
       AddExtension(extension);
     } else {
       RemoveExtension(extension);
     }
   } else {
     NOTREACHED() << "Received unexpected notification";
   }
 }
 
 size_t ExtensionToolbarModel::FindNewPositionFromLastKnownGood(
@@ skipping 15 matching lines @@
         break;
       }
     }
   }
 
   return -1;
 }
 
 void ExtensionToolbarModel::AddExtension(const Extension* extension) {
   // We only care about extensions with browser actions.
-  if (!extensions::ExtensionActionManager::Get(service_->profile())->
+  if (!extensions::ExtensionActionManager::Get(profile_)->
       GetBrowserAction(*extension)) {
     return;
   }
 
   size_t new_index = -1;
 
   // See if we have a last known good position for this extension.
   ExtensionIdList::iterator last_pos = std::find(last_known_positions_.begin(),
                                                  last_known_positions_.end(),
                                                  extension->id());
@@ skipping 44 matching lines @@
   }
 }
 
 // Combine the currently enabled extensions that have browser actions (which
 // we get from the ExtensionService) with the ordering we get from the
 // 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() {
-  DCHECK(service_->is_ready());
+void ExtensionToolbarModel::InitializeExtensionList(ExtensionService* service) {
+  DCHECK(service->is_ready());
 
-  last_known_positions_ = service_->extension_prefs()->GetToolbarOrder();
-  Populate(last_known_positions_);
+  last_known_positions_ = extension_prefs_->GetToolbarOrder();
+  Populate(last_known_positions_, service);
 
   extensions_initialized_ = true;
   FOR_EACH_OBSERVER(Observer, observers_, ModelLoaded());
 }
 
 void ExtensionToolbarModel::Populate(
-    const extensions::ExtensionIdList& positions) {
+    const extensions::ExtensionIdList& positions,
+    ExtensionService* service) {
   // Items that have explicit positions.
   ExtensionList sorted;
   sorted.resize(positions.size(), NULL);
   // The items that don't have explicit positions.
   ExtensionList unsorted;
 
   extensions::ExtensionActionManager* extension_action_manager =
-      extensions::ExtensionActionManager::Get(service_->profile());
+      extensions::ExtensionActionManager::Get(profile_);
 
   // Create the lists.
-  for (ExtensionSet::const_iterator it = service_->extensions()->begin();
-       it != service_->extensions()->end(); ++it) {
+  for (ExtensionSet::const_iterator it = service->extensions()->begin();
+       it != service->extensions()->end(); ++it) {
     const Extension* extension = it->get();
     if (!extension_action_manager->GetBrowserAction(*extension))
       continue;
     if (!extensions::ExtensionActionAPI::GetBrowserActionVisibility(
-            service_->extension_prefs(), extension->id())) {
+            extension_prefs_, extension->id())) {
       continue;
     }
 
     extensions::ExtensionIdList::const_iterator pos =
         std::find(positions.begin(), positions.end(), extension->id());
     if (pos != positions.end())
       sorted[pos - positions.begin()] = extension;
     else
       unsorted.push_back(make_scoped_refptr(extension));
   }
@@ skipping 21 matching lines @@
   toolbar_items_.insert(toolbar_items_.end(), unsorted.begin(),
                         unsorted.end());
 
   // Inform observers.
   for (size_t i = 0; i < toolbar_items_.size(); i++) {
     FOR_EACH_OBSERVER(
         Observer, observers_, BrowserActionAdded(toolbar_items_[i].get(), i));
   }
 }
 
-void ExtensionToolbarModel::FillExtensionList(
-    const extensions::ExtensionIdList& order) {
-  toolbar_items_.clear();
-  toolbar_items_.reserve(order.size());
-  for (size_t i = 0; i < order.size(); ++i) {
-    const extensions::Extension* extension =
-        service_->GetExtensionById(order[i], false);
-    if (extension)
-      AddExtension(extension);
-  }
-}
-
 void ExtensionToolbarModel::UpdatePrefs() {
-  if (!service_->extension_prefs())
+  if (!extension_prefs_)
     return;
 
   // Don't observe change caused by self.
   pref_change_registrar_.Remove(prefs::kExtensionToolbar);
-  service_->extension_prefs()->SetToolbarOrder(last_known_positions_);
+  extension_prefs_->SetToolbarOrder(last_known_positions_);
   pref_change_registrar_.Add(prefs::kExtensionToolbar, pref_change_callback_);
 }
 
 int ExtensionToolbarModel::IncognitoIndexToOriginal(int incognito_index) {
   int original_index = 0, i = 0;
+  ExtensionService* extension_service =
+      extensions::ExtensionSystem::Get(profile_)->extension_service();
   for (ExtensionList::iterator iter = toolbar_items_.begin();
        iter != toolbar_items_.end();
        ++iter, ++original_index) {
-    if (extension_util::IsIncognitoEnabled((*iter)->id(), service_)) {
+    if (extension_util::IsIncognitoEnabled((*iter)->id(), extension_service)) {
       if (incognito_index == i)
         break;
       ++i;
     }
   }
   return original_index;
 }
 
 int ExtensionToolbarModel::OriginalIndexToIncognito(int original_index) {
   int incognito_index = 0, i = 0;
+  ExtensionService* extension_service =
+      extensions::ExtensionSystem::Get(profile_)->extension_service();
   for (ExtensionList::iterator iter = toolbar_items_.begin();
        iter != toolbar_items_.end();
        ++iter, ++i) {
     if (original_index == i)
       break;
-    if (extension_util::IsIncognitoEnabled((*iter)->id(), service_))
+    if (extension_util::IsIncognitoEnabled((*iter)->id(), extension_service))
       ++incognito_index;
   }
   return incognito_index;
 }
 
 void ExtensionToolbarModel::OnExtensionToolbarPrefChange() {
   // If extensions are not ready, defer to later Populate() call.
   if (!extensions_initialized_)
     return;
 
   // Recalculate |last_known_positions_| to be |pref_positions| followed by
   // ones that are only in |last_known_positions_|.
   extensions::ExtensionIdList pref_positions =
-      service_->extension_prefs()->GetToolbarOrder();
+      extension_prefs_->GetToolbarOrder();
   size_t pref_position_size = pref_positions.size();
   for (size_t i = 0; i < last_known_positions_.size(); ++i) {
     if (std::find(pref_positions.begin(), pref_positions.end(),
                   last_known_positions_[i]) == pref_positions.end()) {
       pref_positions.push_back(last_known_positions_[i]);
     }
   }
   last_known_positions_.swap(pref_positions);
 
   // Re-populate.
-  Populate(last_known_positions_);
+  Populate(last_known_positions_,
+           extensions::ExtensionSystem::Get(profile_)->extension_service());
 
   if (last_known_positions_.size() > pref_position_size) {
     // Need to update pref because we have extra icons. But can't call
     // UpdatePrefs() directly within observation closure.
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&ExtensionToolbarModel::UpdatePrefs,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 bool ExtensionToolbarModel::ShowBrowserActionPopup(
     const extensions::Extension* extension) {
   ObserverListBase<Observer>::Iterator it(observers_);
   Observer* obs = NULL;
   while ((obs = it.GetNext()) != NULL) {
     // Stop after first popup since it should only show in the active window.
     if (obs->BrowserActionShowPopup(extension))
       return true;
   }
   return false;
 }