LocationBarView should consistently NULL-check GetWebContents().

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"
 
 #include <algorithm>
 #include <map>
 
 #include "base/command_line.h"
@@ skipping 90 matching lines @@
 #include "chrome/browser/ui/views/first_run_bubble.h"
 #endif
 
 using content::WebContents;
 using views::View;
 
 namespace {
 
 #if !defined(OS_CHROMEOS)
 Browser* GetBrowserFromDelegate(LocationBarView::Delegate* delegate) {
-  WebContents* contents = delegate->GetWebContents();
-  return contents ? chrome::FindBrowserWithWebContents(contents) : NULL;
+  WebContents* web_contents = delegate->GetWebContents();
+  return web_contents ? chrome::FindBrowserWithWebContents(web_contents) : NULL;
 }
 #endif
 
 // Given a containing |height| and a |base_font_list|, shrinks the font size
 // until the font list will fit within |height| while having its cap height
 // vertically centered.  Returns the correctly-sized font list.
 //
 // The expected layout:
 //   +--------+-----------------------------------------------+------------+
 //   |        | y offset                                      | space      |
@@ skipping 390 matching lines @@
   }
 }
 
 void LocationBarView::ZoomChangedForActiveTab(bool can_show_bubble) {
   DCHECK(zoom_view_);
   if (RefreshZoomView()) {
     Layout();
     SchedulePaint();
   }
 
-  if (can_show_bubble && zoom_view_->visible() && delegate_->GetWebContents())
-    ZoomBubbleView::ShowBubble(delegate_->GetWebContents(), true);
+  WebContents* web_contents = GetWebContents();
+  if (can_show_bubble && zoom_view_->visible() && web_contents)
+    ZoomBubbleView::ShowBubble(web_contents, true);
 }
 
 void LocationBarView::SetPreviewEnabledPageAction(ExtensionAction* page_action,
                                                   bool preview_enabled) {
   if (is_popup_mode_)
     return;
 
   DCHECK(page_action);
-  WebContents* contents = delegate_->GetWebContents();
+  WebContents* web_contents = GetWebContents();
 
   RefreshPageActionViews();
   PageActionWithBadgeView* page_action_view =
       static_cast<PageActionWithBadgeView*>(GetPageActionView(page_action));
   DCHECK(page_action_view);
   if (!page_action_view)
     return;
 
   page_action_view->image_view()->set_preview_enabled(preview_enabled);
-  page_action_view->UpdateVisibility(contents, GetToolbarModel()->GetURL());
+  page_action_view->UpdateVisibility(web_contents, GetToolbarModel()->GetURL());
   Layout();
   SchedulePaint();
 }
 
 PageActionWithBadgeView* LocationBarView::GetPageActionView(
     ExtensionAction* page_action) {
   DCHECK(page_action);
   for (PageActionViews::const_iterator i(page_action_views_.begin());
        i != page_action_views_.end(); ++i) {
     if ((*i)->image_view()->page_action() == page_action)
@@ skipping 200 matching lines @@
   const int kEditLeadingInternalSpace = base::i18n::IsRTL() ? 1 : 0;
   LocationBarLayout leading_decorations(
       LocationBarLayout::LEFT_EDGE, item_padding - kEditLeadingInternalSpace);
   LocationBarLayout trailing_decorations(LocationBarLayout::RIGHT_EDGE,
                                          item_padding);
 
   // Show and position the animated host label used in the show and hide URL
   // animations.
   if (show_url_animation_->is_animating() ||
       hide_url_animation_->is_animating()) {
-    const GURL url = GetWebContents()->GetURL();
+    WebContents* web_contents = GetWebContents();
+    const GURL url = web_contents ? web_contents->GetURL() : GURL();
     const base::string16 host =
         OriginChip::LabelFromURLForProfile(url, profile());
     animated_host_label_->SetText(host);
 
     const base::string16 formatted_url = GetToolbarModel()->GetFormattedURL();
 
     // Split the formatted URL on the host name in order to determine the size
     // of the text leading up to it.
     std::vector<base::string16> substrings;
     base::SplitStringUsingSubstr(formatted_url, host, &substrings);
@@ skipping 342 matching lines @@
   // Remember the previous visibility of the page actions so that we can
   // notify when this changes.
   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();
   }
 
   PageActions new_page_actions;
 
-  WebContents* contents = delegate_->GetWebContents();
-  if (contents) {
+  WebContents* web_contents = GetWebContents();
+  if (web_contents) {
     extensions::TabHelper* extensions_tab_helper =
-        extensions::TabHelper::FromWebContents(contents);
+        extensions::TabHelper::FromWebContents(web_contents);
     extensions::LocationBarController* controller =
         extensions_tab_helper->location_bar_controller();
     new_page_actions = controller->GetCurrentActions();
   }
 
   // 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_ != new_page_actions) {
     changed = true;
 
@@ skipping 22 matching lines @@
     DCHECK(right_anchor);
 
     // |page_action_views_| are ordered right-to-left.  Add them as children in
     // reverse order so the logical order and visual order match for
     // accessibility purposes.
     for (PageActionViews::reverse_iterator i = page_action_views_.rbegin();
          i != page_action_views_.rend(); ++i)
       AddChildViewAt(*i, GetIndexOf(right_anchor));
   }
 
-  if (!page_action_views_.empty() && contents) {
-    Browser* browser = chrome::FindBrowserWithWebContents(contents);
+  if (!page_action_views_.empty() && web_contents) {
+    Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
     GURL url = browser->tab_strip_model()->GetActiveWebContents()->GetURL();
 
     for (PageActionViews::const_iterator i(page_action_views_.begin());
          i != page_action_views_.end(); ++i) {
       (*i)->UpdateVisibility(
-          GetToolbarModel()->input_in_progress() ? NULL : contents, url);
+          GetToolbarModel()->input_in_progress() ? NULL : web_contents, url);
 
       // Check if the visibility of the action changed and notify if it did.
       ExtensionAction* action = (*i)->image_view()->page_action();
       if (old_visibility.find(action) == old_visibility.end() ||
           old_visibility[action] != (*i)->visible()) {
         changed = true;
         content::NotificationService::current()->Notify(
             chrome::NOTIFICATION_EXTENSION_PAGE_ACTION_VISIBILITY_CHANGED,
             content::Source<ExtensionAction>(action),
-            content::Details<WebContents>(contents));
+            content::Details<WebContents>(web_contents));
       }
     }
   }
   return changed;
 }
 
 bool LocationBarView::RefreshZoomView() {
   DCHECK(zoom_view_);
   WebContents* web_contents = GetWebContents();
   if (!web_contents)
@@ skipping 472 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // LocationBarView, private content::NotificationObserver implementation:
 
 void LocationBarView::Observe(int type,
                               const content::NotificationSource& source,
                               const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_LOCATION_BAR_UPDATED: {
       // Only update if the updated action box was for the active tab contents.
-      WebContents* target_tab = content::Details<WebContents>(details).ptr();
-      if (target_tab == GetWebContents())
+      if (content::Details<WebContents>(details).ptr() == GetWebContents())
         UpdatePageActions();
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED:
     case chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED:
       Update(NULL);
       break;
 
     default:
       NOTREACHED() << "Unexpected notification.";
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LocationBarView, private SearchModelObserver implementation:
 
 void LocationBarView::ModelChanged(const SearchModel::State& old_state,
                                    const SearchModel::State& new_state) {
   const bool visible = !GetToolbarModel()->input_in_progress() &&
       new_state.voice_search_supported;
   if (mic_search_view_->visible() != visible) {
     mic_search_view_->SetVisible(visible);
     Layout();
   }
 }