Re-factor location bar/toolbar code to get rid of the browser dependency.

chrome/browser/ui/views/location_bar/location_bar_view.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/location_bar/location_bar_view.h"
 
 #if defined(TOOLKIT_USES_GTK)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 97 matching lines @@
   IDR_LOCATION_BAR_SELECTED_KEYWORD_BACKGROUND_R,
 };
 
 // Height of the location bar's round corner region.
 static const int kBorderRoundCornerHeight = 6;
 // Width of location bar's round corner region.
 static const int kBorderRoundCornerWidth = 5;
 
 // LocationBarView -----------------------------------------------------------
 
-LocationBarView::LocationBarView(Browser* browser,
+LocationBarView::LocationBarView(Profile* profile,
+                                 CommandUpdater* command_updater,
                                  ToolbarModel* model,
                                  Delegate* delegate,
                                  Mode mode)
-    : browser_(browser),
+    : profile_(profile),
+      command_updater_(command_updater),
       model_(model),
       delegate_(delegate),
       disposition_(CURRENT_TAB),
       transition_(content::PageTransitionFromInt(
           content::PAGE_TRANSITION_TYPED |
           content::PAGE_TRANSITION_FROM_ADDRESS_BAR)),
       location_icon_view_(NULL),
       ev_bubble_view_(NULL),
       location_entry_view_(NULL),
       selected_keyword_view_(NULL),
@@ skipping 12 matching lines @@
     painter_.reset(
         views::Painter::CreateImagePainter(
             *ResourceBundle::GetSharedInstance().GetImageNamed(
                 IDR_LOCATION_BAR_BORDER).ToSkBitmap(),
             gfx::Insets(kBorderRoundCornerHeight, kBorderRoundCornerWidth,
                 kBorderRoundCornerHeight, kBorderRoundCornerWidth),
             true));
   }
 
   edit_bookmarks_enabled_.Init(prefs::kEditBookmarksEnabled,
-                               browser_->profile()->GetPrefs(), this);
+                               profile_->GetPrefs(), this);
 }
 
 LocationBarView::~LocationBarView() {
   if (template_url_service_)
     template_url_service_->RemoveObserver(this);
 }
 
 void LocationBarView::Init() {
   if (mode_ == POPUP) {
     font_ = ResourceBundle::GetSharedInstance().GetFont(
@@ skipping 17 matching lines @@
 
   ev_bubble_view_ =
       new EVBubbleView(kEVBubbleBackgroundImages, IDR_OMNIBOX_HTTPS_VALID,
                        GetColor(ToolbarModel::EV_SECURE, SECURITY_TEXT), this);
   AddChildView(ev_bubble_view_);
   ev_bubble_view_->SetVisible(false);
   ev_bubble_view_->set_drag_controller(this);
 
   // URL edit field.
   // View container for URL edit field.
-  Profile* profile = browser_->profile();
   location_entry_.reset(OmniboxView::CreateOmniboxView(
       this,
       model_,
-      profile,
-      browser_->command_updater(),
+      profile_,
+      command_updater_,
       mode_ == POPUP,
       this));
   SetLocationEntryFocusable(true);
 
   location_entry_view_ = location_entry_->AddToView(this);
   location_entry_view_->set_id(VIEW_ID_AUTOCOMPLETE);
 
   selected_keyword_view_ = new SelectedKeywordView(
       kSelectedKeywordBackgroundImages, IDR_KEYWORD_SEARCH_MAGNIFIER,
-      GetColor(ToolbarModel::NONE, TEXT), profile);
+      GetColor(ToolbarModel::NONE, TEXT), profile_);
   AddChildView(selected_keyword_view_);
   selected_keyword_view_->SetFont(font_);
   selected_keyword_view_->SetVisible(false);
 
-  keyword_hint_view_ = new KeywordHintView(profile);
+  keyword_hint_view_ = new KeywordHintView(profile_);
   AddChildView(keyword_hint_view_);
   keyword_hint_view_->SetVisible(false);
   keyword_hint_view_->SetFont(font_);
 
   for (int i = 0; i < CONTENT_SETTINGS_NUM_TYPES; ++i) {
     ContentSettingImageView* content_blocked_view =
-        new ContentSettingImageView(static_cast<ContentSettingsType>(i), this);
+        new ContentSettingImageView(
+            static_cast<ContentSettingsType>(i),
+            this);
     content_setting_views_.push_back(content_blocked_view);
     AddChildView(content_blocked_view);
     content_blocked_view->SetVisible(false);
   }
 
   // The star is not visible in popups and in the app launcher.
   if (browser_defaults::bookmarks_enabled && (mode_ == NORMAL)) {
-    star_view_ = new StarView(browser_->command_updater());
+    star_view_ = new StarView(command_updater_);
     AddChildView(star_view_);
     star_view_->SetVisible(true);
   }
 
   // Initialize the location entry. We do this to avoid a black flash which is
   // visible when the location entry has just been initialized.
   Update(NULL);
 
   OnChanged();
 }
@@ skipping 56 matching lines @@
   FocusLocation(select_all);
 }
 
 void LocationBarView::SetAnimationOffset(int offset) {
   animation_offset_ = offset;
 }
 
 void LocationBarView::Update(const WebContents* tab_for_state_restoring) {
   bool star_enabled = star_view_ && !model_->input_in_progress() &&
                       edit_bookmarks_enabled_.GetValue();
-  browser_->command_updater()->UpdateCommandEnabled(
+  command_updater_->UpdateCommandEnabled(
       IDC_BOOKMARK_PAGE, star_enabled);
   if (star_view_)
     star_view_->SetVisible(star_enabled);
   RefreshContentSettingViews();
   RefreshPageActionViews();
   // Don't Update in app launcher mode so that the location entry does not show
   // a URL or security background.
   if (mode_ != APP_LAUNCHER)
     location_entry_->Update(tab_for_state_restoring);
   OnChanged();
@@ skipping 75 matching lines @@
   }
   return NULL;
 }
 
 void LocationBarView::SetStarToggled(bool on) {
   if (star_view_)
     star_view_->SetToggled(on);
 }
 
 void LocationBarView::ShowStarBubble(const GURL& url, bool newly_bookmarked) {
-  browser::ShowBookmarkBubbleView(star_view_, browser_->profile(), url,
+  browser::ShowBookmarkBubbleView(star_view_, profile_, url,
                                   newly_bookmarked);
 }
 
 gfx::Point LocationBarView::GetLocationEntryOrigin() const {
   gfx::Point origin(location_entry_view_->bounds().origin());
   // If the UI layout is RTL, the coordinate system is not transformed and
   // therefore we need to adjust the X coordinate so that bubble appears on the
   // right hand side of the location bar.
   if (base::i18n::IsRTL())
     origin.set_x(width() - origin.x());
@@ skipping 145 matching lines @@
   if (max_edit_width < 0)
     return;
   const int available_width = AvailableWidth(max_edit_width);
 
   const bool show_keyword_hint = !keyword.empty() && is_keyword_hint;
   selected_keyword_view_->SetVisible(show_selected_keyword);
   keyword_hint_view_->SetVisible(show_keyword_hint);
   if (show_selected_keyword) {
     if (selected_keyword_view_->keyword() != keyword) {
       selected_keyword_view_->SetKeyword(keyword);
-      Profile* profile = browser_->profile();
       const TemplateURL* template_url =
-          TemplateURLServiceFactory::GetForProfile(profile)->
+          TemplateURLServiceFactory::GetForProfile(profile_)->
           GetTemplateURLForKeyword(keyword);
       if (template_url && template_url->IsExtensionKeyword()) {
-        const SkBitmap& bitmap = profile->GetExtensionService()->GetOmniboxIcon(
-            template_url->GetExtensionId());
+        const SkBitmap& bitmap =
+            profile_->GetExtensionService()->GetOmniboxIcon(
+                template_url->GetExtensionId());
         selected_keyword_view_->SetImage(bitmap);
         selected_keyword_view_->set_is_extension_icon(true);
       } else {
         selected_keyword_view_->SetImage(*ResourceBundle::GetSharedInstance().
             GetBitmapNamed(IDR_OMNIBOX_SEARCH));
         selected_keyword_view_->set_is_extension_icon(false);
       }
     }
   } else if (show_keyword_hint) {
     if (keyword_hint_view_->keyword() != keyword)
@@ skipping 227 matching lines @@
     content::PageTransition transition,
     const GURL& alternate_nav_url) {
   // WARNING: don't add an early return here. The calls after the if must
   // happen.
   if (url.is_valid()) {
     location_input_ = UTF8ToUTF16(url.spec());
     disposition_ = disposition;
     transition_ = content::PageTransitionFromInt(
         transition | content::PAGE_TRANSITION_FROM_ADDRESS_BAR);
 
-    if (browser_->command_updater()) {
+    if (command_updater_) {
       if (!alternate_nav_url.is_valid()) {
-        browser_->command_updater()->ExecuteCommand(IDC_OPEN_CURRENT_URL);
+        command_updater_->ExecuteCommand(IDC_OPEN_CURRENT_URL);
       } else {
         AlternateNavURLFetcher* fetcher =
             new AlternateNavURLFetcher(alternate_nav_url);
         // The AlternateNavURLFetcher will listen for the pending navigation
         // notification that will be issued as a result of the "open URL." It
         // will automatically install itself into that navigation controller.
-        browser_->command_updater()->ExecuteCommand(IDC_OPEN_CURRENT_URL);
+        command_updater_->ExecuteCommand(IDC_OPEN_CURRENT_URL);
         if (fetcher->state() == AlternateNavURLFetcher::NOT_STARTED) {
           // I'm not sure this should be reachable, but I'm not also sure enough
           // that it shouldn't to stick in a NOTREACHED().  In any case, this is
           // harmless.
           delete fetcher;
         } else {
           // The navigation controller will delete the fetcher.
         }
       }
     }
@@ skipping 86 matching lines @@
   for (PageActionViews::const_iterator i(page_action_views_.begin());
        i != page_action_views_.end(); ++i)
     RemoveChildView(*i);
   STLDeleteElements(&page_action_views_);
 }
 
 void LocationBarView::RefreshPageActionViews() {
   if (mode_ != NORMAL)
     return;
 
-  ExtensionService* service = browser_->profile()->GetExtensionService();
+  ExtensionService* service = profile_->GetExtensionService();
   if (!service)
     return;
 
   std::map<ExtensionAction*, bool> old_visibility;
   for (PageActionViews::const_iterator i(page_action_views_.begin());
        i != page_action_views_.end(); ++i)
     old_visibility[(*i)->image_view()->page_action()] = (*i)->visible();
 
   // Remember the previous visibility of the page actions so that we can
   // notify when this changes.
   std::vector<ExtensionAction*> page_actions;
   for (ExtensionSet::const_iterator it = service->extensions()->begin();
        it != service->extensions()->end(); ++it) {
     if ((*it)->page_action())
       page_actions.push_back((*it)->page_action());
   }
 
   // On startup we sometimes haven't loaded any extensions. This makes sure
   // we catch up when the extensions (and any page actions) load.
   if (page_actions.size() != page_action_views_.size()) {
     DeletePageActionViews();  // Delete the old views (if any).
 
     page_action_views_.resize(page_actions.size());
 
     // Add the page actions in reverse order, so that the child views are
     // inserted in left-to-right order for accessibility.
     for (int i = page_actions.size() - 1; i >= 0; --i) {
       page_action_views_[i] = new PageActionWithBadgeView(
-          new PageActionImageView(this, page_actions[i]));
+          delegate_->CreatePageActionImageView(this, page_actions[i]));
       page_action_views_[i]->SetVisible(false);
       AddChildViewAt(page_action_views_[i], GetIndexOf(star_view_));
     }
   }
 
   WebContents* contents = GetWebContentsFromDelegate(delegate_);
   if (!page_action_views_.empty() && contents) {
     GURL url = GURL(model_->GetText());
 
     for (PageActionViews::const_iterator i(page_action_views_.begin());
@@ skipping 22 matching lines @@
   if (views::Widget::IsPureViews())
     NOTIMPLEMENTED();
   else
     GetOmniboxViewWin()->HandleExternalMsg(msg, flags, screen_point.ToPOINT());
 }
 #endif
 
 void LocationBarView::ShowFirstRunBubbleInternal() {
 #if !defined(OS_CHROMEOS)
   // First run bubble doesn't make sense for Chrome OS.
-  FirstRunBubble::ShowBubble(browser_->profile(), location_icon_view_);
+  FirstRunBubble::ShowBubble(profile_, location_icon_view_);
 #endif
 }
 
 std::string LocationBarView::GetClassName() const {
   return kViewClassName;
 }
 
 bool LocationBarView::SkipDefaultKeyEventProcessing(
     const views::KeyEvent& event) {
 #if defined(OS_WIN)
@@ skipping 69 matching lines @@
                                           const gfx::Point& p) {
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LocationBarView, LocationBar implementation:
 
 void LocationBarView::ShowFirstRunBubble() {
   // Wait until search engines have loaded to show the first run bubble.
   TemplateURLService* url_service =
-      TemplateURLServiceFactory::GetForProfile(browser_->profile());
+      TemplateURLServiceFactory::GetForProfile(profile_);
   if (!url_service->loaded()) {
     template_url_service_ = url_service;
     template_url_service_->AddObserver(this);
     template_url_service_->Load();
     return;
   }
   ShowFirstRunBubbleInternal();
 }
 
 void LocationBarView::SetSuggestedText(const string16& text,
@@ skipping 126 matching lines @@
       !suggested_text_view_->GetText().empty();
 }
 
 #if !defined(USE_AURA)
 OmniboxViewWin* LocationBarView::GetOmniboxViewWin() {
   CHECK(!views::Widget::IsPureViews());
   return static_cast<OmniboxViewWin*>(location_entry_.get());
 }
 #endif
 #endif