views: Cleanup BrowserView function order and variable names

chrome/browser/ui/views/frame/browser_view.cc

 // Copyright 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/frame/browser_view.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
@@ skipping 421 matching lines @@
     : views::ClientView(NULL, NULL),
       last_focused_view_storage_id_(
           views::ViewStorage::GetInstance()->CreateStorageID()),
       frame_(NULL),
       browser_(browser),
       top_container_(NULL),
       tabstrip_(NULL),
       toolbar_(NULL),
       window_switcher_button_(NULL),
       infobar_container_(NULL),
+      contents_web_view_(NULL),
+      devtools_container_(NULL),
       contents_container_(NULL),
-      devtools_container_(NULL),
-      contents_(NULL),
       contents_split_(NULL),
       devtools_dock_side_(DEVTOOLS_DOCK_SIDE_BOTTOM),
       devtools_window_(NULL),
       initialized_(false),
       ignore_layout_(true),
 #if defined(OS_WIN) && !defined(USE_AURA)
       hung_window_detector_(&hung_plugin_action_),
       ticker_(0),
 #endif
       force_location_bar_focus_(false),
@@ skipping 72 matching lines @@
 gfx::Rect BrowserView::GetToolbarBounds() const {
   gfx::Rect toolbar_bounds(toolbar_->bounds());
   if (toolbar_bounds.IsEmpty())
     return toolbar_bounds;
   // The apparent toolbar edges are outside the "real" toolbar edges.
   toolbar_bounds.Inset(-views::NonClientFrameView::kClientEdgeThickness, 0);
   return toolbar_bounds;
 }
 
 gfx::Rect BrowserView::GetClientAreaBounds() const {
-  gfx::Rect container_bounds = contents_->bounds();
+  gfx::Rect container_bounds = contents_container_->bounds();
   gfx::Point container_origin = container_bounds.origin();
   ConvertPointToTarget(this, parent(), &container_origin);
   container_bounds.set_origin(container_origin);
   return container_bounds;
 }
 
 gfx::Rect BrowserView::GetFindBarBoundingBox() const {
   return GetBrowserViewLayout()->GetFindBarBoundingBox();
 }
 
@@ skipping 19 matching lines @@
   if (immersive_mode_controller_->ShouldHideTopViews() &&
       immersive_mode_controller_->ShouldHideTabIndicators())
     return false;
   return browser_->SupportsWindowFeature(Browser::FEATURE_TABSTRIP);
 }
 
 bool BrowserView::IsOffTheRecord() const {
   return browser_->profile()->IsOffTheRecord();
 }
 
+int BrowserView::GetOTRIconResourceID() const {
+  int otr_resource_id = IDR_OTR_ICON;
+  if (ui::GetDisplayLayout() == ui::LAYOUT_TOUCH) {
+    if (IsFullscreen())
+      otr_resource_id = IDR_OTR_ICON_FULLSCREEN;
+#if defined(OS_WIN)
+    if (win8::IsSingleWindowMetroMode())
+      otr_resource_id = IDR_OTR_ICON_FULLSCREEN;
+#endif
+  }
+
+  return otr_resource_id;
+}
+
 bool BrowserView::IsGuestSession() const {
   return browser_->profile()->IsGuestSession();
 }
 
 bool BrowserView::ShouldShowAvatar() const {
   if (!IsBrowserTypeNormal())
     return false;
   if (IsOffTheRecord() && !IsGuestSession())
     return true;
   if (ManagedMode::IsInManagedMode())
     return true;
 
   ProfileInfoCache& cache =
       g_browser_process->profile_manager()->GetProfileInfoCache();
   if (cache.GetIndexOfProfileWithPath(browser_->profile()->GetPath()) ==
       std::string::npos) {
     return false;
   }
 
   return AvatarMenuModel::ShouldShowAvatarMenu();
 }
 
-bool BrowserView::AcceleratorPressed(const ui::Accelerator& accelerator) {
-#if defined(OS_CHROMEOS)
-  // If accessibility is enabled, stop speech and return false so that key
-  // combinations involving Search can be used for extra accessibility
-  // functionality.
-  if (accelerator.key_code() == ui::VKEY_LWIN &&
-      g_browser_process->local_state()->GetBoolean(
-          prefs::kSpokenFeedbackEnabled)) {
-    TtsController::GetInstance()->Stop();
-    return false;
-  }
-#endif
-
-  std::map<ui::Accelerator, int>::const_iterator iter =
-      accelerator_table_.find(accelerator);
-  DCHECK(iter != accelerator_table_.end());
-  int command_id = iter->second;
-
-  chrome::BrowserCommandController* controller = browser_->command_controller();
-  if (!controller->block_command_execution())
-    UpdateAcceleratorMetrics(accelerator, command_id);
-  return chrome::ExecuteCommand(browser_.get(), command_id);
-}
-
 bool BrowserView::GetAccelerator(int cmd_id, ui::Accelerator* accelerator) {
   // We retrieve the accelerator information for standard accelerators
   // for cut, copy and paste.
   if (chrome::GetStandardAcceleratorForCommandId(cmd_id, accelerator))
     return true;
   // Else, we retrieve the accelerator information from the accelerator table.
   for (std::map<ui::Accelerator, int>::const_iterator it =
            accelerator_table_.begin(); it != accelerator_table_.end(); ++it) {
     if (it->second == cmd_id) {
       *accelerator = it->first;
@@ skipping 57 matching lines @@
   // If we do find there are cases where we need to restore the focus on show,
   // that should be added and this should be removed.
   RestoreFocus();
 
   frame_->Show();
 
   force_location_bar_focus_ = false;
 
   browser()->OnWindowDidShow();
 
-  chrome::MaybeShowInvertBubbleView(browser_.get(), contents_);
+  chrome::MaybeShowInvertBubbleView(browser_.get(), contents_container_);
 }
 
 void BrowserView::ShowInactive() {
   if (frame_->IsVisible())
     return;
   CreateLauncherIcon();
   frame_->ShowInactive();
 }
 
 void BrowserView::Hide() {
@@ skipping 226 matching lines @@
   // reentrancy; |call_state| tracks whether we're reentrant.  We can't just
   // early-return in this case because we need to layout again so the infobar
   // container's bounds are set correctly.
   static CallState call_state = NORMAL;
 
   // A reentrant call can (and should) use the fast resize path unless both it
   // and the normal call are both non-animating.
   bool use_fast_resize =
       is_animating || (call_state == REENTRANT_FORCE_FAST_RESIZE);
   if (use_fast_resize)
-    contents_container_->SetFastResize(true);
+    contents_web_view_->SetFastResize(true);
   UpdateUIForContents(GetActiveWebContents());
   if (use_fast_resize)
-    contents_container_->SetFastResize(false);
+    contents_web_view_->SetFastResize(false);
 
   // Inform the InfoBarContainer that the distance to the location icon may have
   // changed.  We have to do this after the block above so that the toolbars are
   // laid out correctly for calculating the maximum arrow height below.
   {
     int top_arrow_height = 0;
     // Hide the arrows on the Instant Extended NTP.
     if (!chrome::IsInstantExtendedAPIEnabled() ||
         !browser()->search_model()->mode().is_ntp()) {
       const LocationIconView* location_icon_view =
@@ skipping 11 matching lines @@
     infobar_container_->SetMaxTopArrowHeight(top_arrow_height);
   }
 
   // When transitioning from animating to not animating we need to make sure the
   // contents_container_ gets layed out. If we don't do this and the bounds
   // haven't changed contents_container_ won't get a Layout out and we'll end up
   // with a gray rect because the clip wasn't updated.  Note that a reentrant
   // call never needs to do this, because after it returns, the normal call
   // wrapping it will do it.
   if ((call_state == NORMAL) && !is_animating) {
-    contents_container_->InvalidateLayout();
+    contents_web_view_->InvalidateLayout();
     contents_split_->Layout();
   }
 }
 
 void BrowserView::MaybeStackImmersiveRevealAtTop() {
   immersive_mode_controller_->MaybeStackViewAtTop();
 }
 
 LocationBar* BrowserView::GetLocationBar() const {
   return GetLocationBarView();
@@ skipping 296 matching lines @@
 void BrowserView::UserChangedTheme() {
   frame_->FrameTypeChanged();
 }
 
 int BrowserView::GetExtraRenderViewHeight() const {
   // Currently this is only used on linux.
   return 0;
 }
 
 void BrowserView::WebContentsFocused(WebContents* contents) {
-  if (contents_container_->GetWebContents() == contents)
-    contents_container_->OnWebContentsFocused(contents);
-  else if (contents_->overlay_web_contents() == contents)
+  if (contents_web_view_->GetWebContents() == contents)
+    contents_web_view_->OnWebContentsFocused(contents);
+  else if (contents_container_->overlay_web_contents() == contents)
     overlay_controller_->overlay()->OnWebContentsFocused(contents);
   else
     devtools_container_->OnWebContentsFocused(contents);
 }
 
 void BrowserView::ShowWebsiteSettings(Profile* profile,
                                       content::WebContents* web_contents,
                                       const GURL& url,
                                       const content::SSLStatus& ssl,
                                       bool show_history) {
@@ skipping 123 matching lines @@
 
 void BrowserView::Paste() {
   DoCutCopyPaste(&content::RenderWidgetHost::Paste,
 #if defined(OS_WIN)
                  WM_PASTE,
 #endif
                  IDS_APP_PASTE);
 }
 
 gfx::Rect BrowserView::GetInstantBounds() {
-  return contents_->GetOverlayBounds();
+  return contents_container_->GetOverlayBounds();
 }
 
 WindowOpenDisposition BrowserView::GetDispositionForPopupBounds(
     const gfx::Rect& bounds) {
 #if defined(OS_WIN)
   // If we are in Win8's single window Metro mode, we can't allow popup windows.
   return win8::IsSingleWindowMetroMode() ? NEW_BACKGROUND_TAB : NEW_POPUP;
 #else
   return NEW_POPUP;
 #endif
@@ skipping 12 matching lines @@
 
 BookmarkBarView* BrowserView::GetBookmarkBarView() const {
   return bookmark_bar_view_.get();
 }
 
 LocationBarView* BrowserView::GetLocationBarView() const {
   return toolbar_ ? toolbar_->location_bar() : NULL;
 }
 
 views::View* BrowserView::GetTabContentsContainerView() const {
-  return contents_container_;
+  return contents_web_view_;
 }
 
 ToolbarView* BrowserView::GetToolbarView() const {
   return toolbar_;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserView, TabStripModelObserver implementation:
 
 void BrowserView::TabDetachedAt(WebContents* contents, int index) {
   // We use index here rather than comparing |contents| because by this time
   // the model has already removed |contents| from its list, so
   // browser_->GetActiveWebContents() will return NULL or something else.
   if (index == browser_->tab_strip_model()->active_index()) {
     // We need to reset the current tab contents to NULL before it gets
     // freed. This is because the focus manager performs some operations
     // on the selected WebContents when it is removed.
-    contents_container_->SetWebContents(NULL);
+    contents_web_view_->SetWebContents(NULL);
     infobar_container_->ChangeInfoBarService(NULL);
     UpdateDevToolsForContents(NULL);
   }
 }
 
 void BrowserView::TabDeactivated(WebContents* contents) {
   // We do not store the focus when closing the tab to work-around bug 4633.
   // Some reports seem to show that the focus manager and/or focused view can
   // be garbage at that point, it is not clear why.
   if (!contents->IsBeingDestroyed())
     contents->GetView()->StoreFocus();
 }
 
 void BrowserView::ActiveTabChanged(content::WebContents* old_contents,
                                    content::WebContents* new_contents,
                                    int index,
                                    int reason) {
   DCHECK(new_contents);
 
   // See if the Instant overlay is being activated (committed).
-  if (contents_->overlay_web_contents() == new_contents) {
-    contents_->MakeOverlayContentsActiveContents();
-    views::WebView* old_container = contents_container_;
-    contents_container_ = overlay_controller_->release_overlay();
+  if (contents_container_->overlay_web_contents() == new_contents) {
+    contents_container_->MakeOverlayContentsActiveContents();
+    views::WebView* old_container = contents_web_view_;
+    contents_web_view_ = overlay_controller_->release_overlay();
     old_container->SetWebContents(NULL);
     delete old_container;
   }
 
   // If |contents_container_| already has the correct WebContents, we can save
   // some work.  This also prevents extra events from being reported by the
   // Visibility API under Windows, as ChangeWebContents will briefly hide
   // the WebContents window.
   bool change_tab_contents =
-      contents_container_->web_contents() != new_contents;
+      contents_web_view_->web_contents() != new_contents;
 
   // Update various elements that are interested in knowing the current
   // WebContents.
 
   // When we toggle the NTP floating bookmarks bar and/or the info bar,
   // we don't want any WebContents to be attached, so that we
   // avoid an unnecessary resize and re-layout of a WebContents.
   if (change_tab_contents)
-    contents_container_->SetWebContents(NULL);
+    contents_web_view_->SetWebContents(NULL);
   infobar_container_->ChangeInfoBarService(
       InfoBarService::FromWebContents(new_contents));
   if (bookmark_bar_view_.get()) {
     bookmark_bar_view_->SetBookmarkBarState(
         browser_->bookmark_bar_state(),
         BookmarkBar::DONT_ANIMATE_STATE_CHANGE);
   }
   UpdateUIForContents(new_contents);
 
   // Layout for DevTools _before_ setting the main WebContents to avoid
   // toggling the size of the main WebContents.
   UpdateDevToolsForContents(new_contents);
 
   if (change_tab_contents) {
-    contents_container_->SetWebContents(new_contents);
-    contents_->MaybeStackOverlayAtTop();
+    contents_web_view_->SetWebContents(new_contents);
+    contents_container_->MaybeStackOverlayAtTop();
   }
 
   if (!browser_->tab_strip_model()->closing_all() && GetWidget()->IsActive() &&
       GetWidget()->IsVisible()) {
     // We only restore focus if our window is visible, to avoid invoking blur
     // handlers when we are eventually shown.
     new_contents->GetView()->RestoreFocus();
   }
 
   // Update all the UI bits.
@@ skipping 207 matching lines @@
   }
 
   // We return true because we can _always_ locate reasonable bounds using the
   // WindowSizer, and we don't want to trigger the Window's built-in "size to
   // default" handling because the browser window has no default preferred
   // size.
   return true;
 }
 
 views::View* BrowserView::GetContentsView() {
-  return contents_container_;
+  return contents_web_view_;
 }
 
 views::ClientView* BrowserView::CreateClientView(views::Widget* widget) {
   return this;
 }
 
 void BrowserView::OnWidgetActivationChanged(views::Widget* widget,
                                             bool active) {
 #if defined(USE_ASH)
   if (launcher_item_controller_.get())
@@ skipping 146 matching lines @@
 
 void BrowserView::ChildPreferredSizeChanged(View* child) {
   Layout();
 }
 
 void BrowserView::GetAccessibleState(ui::AccessibleViewState* state) {
   state->role = ui::AccessibilityTypes::ROLE_CLIENT;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// BrowserView, protected
+// BrowserView, ui::AcceleratorTarget overrides:
+
+bool BrowserView::AcceleratorPressed(const ui::Accelerator& accelerator) {
+#if defined(OS_CHROMEOS)
+  // If accessibility is enabled, stop speech and return false so that key
+  // combinations involving Search can be used for extra accessibility
+  // functionality.
+  if (accelerator.key_code() == ui::VKEY_LWIN &&
+      g_browser_process->local_state()->GetBoolean(
+          prefs::kSpokenFeedbackEnabled)) {
+    TtsController::GetInstance()->Stop();
+    return false;
+  }
+#endif
+
+  std::map<ui::Accelerator, int>::const_iterator iter =
+      accelerator_table_.find(accelerator);
+  DCHECK(iter != accelerator_table_.end());
+  int command_id = iter->second;
+
+  chrome::BrowserCommandController* controller = browser_->command_controller();
+  if (!controller->block_command_execution())
+    UpdateAcceleratorMetrics(accelerator, command_id);
+  return chrome::ExecuteCommand(browser_.get(), command_id);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// BrowserView, private
 
 void BrowserView::GetAccessiblePanes(
     std::vector<views::AccessiblePaneView*>* panes) {
   // This should be in the order of pane traversal of the panes using F6.
   // If one of these is invisible or has no focusable children, it will be
   // automatically skipped.
   panes->push_back(toolbar_);
   if (bookmark_bar_view_.get())
     panes->push_back(bookmark_bar_view_.get());
   if (infobar_container_)
@@ skipping 27 matching lines @@
 
 bool BrowserView::SplitHandleMoved(views::SingleSplitView* sender) {
   for (int i = 0; i < sender->child_count(); ++i)
     sender->child_at(i)->InvalidateLayout();
   SchedulePaint();
   Layout();
   return false;
 }
 
 void BrowserView::OnSysColorChange() {
-  chrome::MaybeShowInvertBubbleView(browser_.get(), contents_);
-}
-
-int BrowserView::GetOTRIconResourceID() const {
-  int otr_resource_id = IDR_OTR_ICON;
-  if (ui::GetDisplayLayout() == ui::LAYOUT_TOUCH) {
-    if (IsFullscreen())
-      otr_resource_id = IDR_OTR_ICON_FULLSCREEN;
-#if defined(OS_WIN)
-    if (win8::IsSingleWindowMetroMode())
-      otr_resource_id = IDR_OTR_ICON_FULLSCREEN;
-#endif
-  }
-
-  return otr_resource_id;
+  chrome::MaybeShowInvertBubbleView(browser_.get(), contents_container_);
 }
 
 void BrowserView::Init() {
   GetWidget()->AddObserver(this);
 
   SetLayoutManager(new BrowserViewLayout);
   // Stow a pointer to this object onto the window handle so that we can get at
   // it later when all we have is a native view.
   GetWidget()->SetNativeWindowProperty(kBrowserViewKey, this);
 
@@ skipping 11 matching lines @@
           switches::kDisableHangMonitor)) {
     InitHangMonitor();
   }
 
   LoadAccelerators();
 
   infobar_container_ = new InfoBarContainerView(this,
                                                 browser()->search_model());
   AddChildView(infobar_container_);
 
-  contents_container_ = new views::WebView(browser_->profile());
-  contents_container_->set_id(VIEW_ID_TAB_CONTAINER);
-  contents_ = new ContentsContainer(contents_container_, this);
+  contents_web_view_ = new views::WebView(browser_->profile());
+  contents_web_view_->set_id(VIEW_ID_TAB_CONTAINER);
+  contents_container_ = new ContentsContainer(contents_web_view_, this);
 
   overlay_controller_.reset(
-      new InstantOverlayControllerViews(browser(), contents_));
+      new InstantOverlayControllerViews(browser(), contents_container_));
 
   SkColor bg_color = GetWidget()->GetThemeProvider()->
       GetColor(ThemeProperties::COLOR_TOOLBAR);
 
   devtools_container_ = new views::WebView(browser_->profile());
   devtools_container_->set_id(VIEW_ID_DEV_TOOLS_DOCKED);
   devtools_container_->SetVisible(false);
 
-  views::View* contents_view = contents_;
+  views::View* contents_container_view = contents_container_;
 
   contents_split_ = new views::SingleSplitView(
-      contents_view,
+      contents_container_view,
       devtools_container_,
       views::SingleSplitView::VERTICAL_SPLIT,
       this);
   contents_split_->set_id(VIEW_ID_CONTENTS_SPLIT);
   contents_split_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_ACCNAME_WEB_CONTENTS));
   contents_split_->set_background(
       views::Background::CreateSolidBackground(bg_color));
   AddChildView(contents_split_);
   set_contents_view(contents_split_);
 
-  status_bubble_.reset(new StatusBubbleViews(contents_));
+  status_bubble_.reset(new StatusBubbleViews(contents_container_));
 
   // Top container holds tab strip and toolbar and lives at the front of the
   // view hierarchy.
   top_container_ = new TopContainerView(this);
   AddChildView(top_container_);
 
   // TabStrip takes ownership of the controller.
   BrowserTabStripController* tabstrip_controller =
       new BrowserTabStripController(browser_.get(),
                                     browser_->tab_strip_model());
@@ skipping 44 matching lines @@
 }
 
 void BrowserView::OnLoadCompleted() {
 #if defined(OS_WIN) && !defined(USE_AURA)
   DCHECK(!jumplist_);
   jumplist_ = new JumpList();
   jumplist_->AddObserver(browser_->profile());
 #endif
 }
 
-// BrowserView, private --------------------------------------------------------
-
 BrowserViewLayout* BrowserView::GetBrowserViewLayout() const {
   return static_cast<BrowserViewLayout*>(GetLayoutManager());
 }
 
 void BrowserView::LayoutStatusBubble() {
   // In restored mode, the client area has a client edge between it and the
   // frame.
   int overlap = StatusBubbleViews::kShadowThickness;
   // The extra pixels defined by kClientEdgeThickness is only drawn in frame
   // content border on windows for non-aura build.
@@ skipping 577 matching lines @@
 
   Browser* modal_browser =
       chrome::FindBrowserWithWebContents(active_dialog->web_contents());
   if (modal_browser && (browser_ != modal_browser)) {
     modal_browser->window()->FlashFrame(true);
     modal_browser->window()->Activate();
   }
 
   AppModalDialogQueue::GetInstance()->ActivateModalDialog();
 }