Variety of tweaks to View API.

chrome/browser/ui/views/location_bar/location_bar_view.cc

 // Copyright (c) 2011 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 106 matching lines @@
       suggested_text_view_(NULL),
 #endif
       keyword_hint_view_(NULL),
       star_view_(NULL),
       mode_(mode),
       show_focus_rect_(false),
       bubble_type_(FirstRun::MINIMAL_BUBBLE),
       template_url_model_(NULL),
       animation_offset_(0) {
   DCHECK(profile_);
-  SetID(VIEW_ID_LOCATION_BAR);
-  SetFocusable(true);
+  set_id(VIEW_ID_LOCATION_BAR);
+  set_focusable(true);
 
   if (mode_ == NORMAL)
     painter_.reset(new views::HorizontalPainter(kNormalModeBackgroundImages));
 
   edit_bookmarks_enabled_.Init(prefs::kEditBookmarksEnabled,
                                profile_->GetPrefs(), this);
 }
 
 LocationBarView::~LocationBarView() {
   if (template_url_model_)
@@ skipping 33 matching lines @@
 #if defined(OS_WIN)
   location_entry_.reset(new OmniboxViewWin(font_, this, model_, this,
       GetWidget()->GetNativeView(), profile_, browser_->command_updater(),
       mode_ == POPUP, this));
 #else
   location_entry_.reset(OmniboxViewGtk::Create(this, model_, profile_,
       browser_->command_updater(), mode_ == POPUP, this));
 #endif
 
   location_entry_view_ = location_entry_->AddToView(this);
-  location_entry_view_->SetID(VIEW_ID_AUTOCOMPLETE);
+  location_entry_view_->set_id(VIEW_ID_AUTOCOMPLETE);
 
   selected_keyword_view_ = new SelectedKeywordView(
       kSelectedKeywordBackgroundImages, IDR_KEYWORD_SEARCH_MAGNIFIER,
       GetColor(ToolbarModel::NONE, TEXT), profile_),
   AddChildView(selected_keyword_view_);
   selected_keyword_view_->SetFont(font_);
   selected_keyword_view_->SetVisible(false);
 
   SkColor dimmed_text = GetColor(ToolbarModel::NONE, DEEMPHASIZED_TEXT);
 
@@ skipping 302 matching lines @@
     ev_bubble_view_->SetLabel(model_->GetEVCertName());
     ev_bubble_width = ev_bubble_view_->GetPreferredSize().width();
     // We'll adjust this width and take it out of |entry_width| below.
   } else {
     location_icon_view_->SetVisible(true);
     location_icon_width = location_icon_view_->GetPreferredSize().width();
     entry_width -= (kEdgeThickness + kEdgeItemPadding + location_icon_width +
         kItemEditPadding);
   }
 
-  if (star_view_ && star_view_->IsVisible())
+  if (star_view_ && star_view_->visible())
     entry_width -= star_view_->GetPreferredSize().width() + kItemPadding;
   for (PageActionViews::const_iterator i(page_action_views_.begin());
        i != page_action_views_.end(); ++i) {
-    if ((*i)->IsVisible())
+    if ((*i)->visible())
       entry_width -= ((*i)->GetPreferredSize().width() + kItemPadding);
   }
   for (ContentSettingViews::const_iterator i(content_setting_views_.begin());
        i != content_setting_views_.end(); ++i) {
-    if ((*i)->IsVisible())
+    if ((*i)->visible())
       entry_width -= ((*i)->GetPreferredSize().width() + kItemPadding);
   }
   // The gap between the edit and whatever is to its right is shortened.
   entry_width += kEditInternalSpace;
 
   // Size the EV bubble.  We do this after taking the star/page actions/content
   // settings out of |entry_width| so we won't take too much space.
   if (ev_bubble_width) {
     // Try to elide the bubble to be no larger than half the total available
     // space, but never elide it any smaller than 150 px.
@@ skipping 40 matching lines @@
         selected_keyword_view_->set_is_extension_icon(false);
       }
     }
   } else if (show_keyword_hint) {
     if (keyword_hint_view_->keyword() != keyword)
       keyword_hint_view_->SetKeyword(keyword);
   }
 
   // Lay out items to the right of the edit field.
   int offset = width() - kEdgeThickness - kEdgeItemPadding;
-  if (star_view_ && star_view_->IsVisible()) {
+  if (star_view_ && star_view_->visible()) {
     int star_width = star_view_->GetPreferredSize().width();
     offset -= star_width;
     star_view_->SetBounds(offset, location_y, star_width, location_height);
     offset -= kItemPadding;
   }
 
   for (PageActionViews::const_iterator i(page_action_views_.begin());
        i != page_action_views_.end(); ++i) {
-    if ((*i)->IsVisible()) {
+    if ((*i)->visible()) {
       int page_action_width = (*i)->GetPreferredSize().width();
       offset -= page_action_width;
       (*i)->SetBounds(offset, location_y, page_action_width, location_height);
       offset -= kItemPadding;
     }
   }
   // We use a reverse_iterator here because we're laying out the views from
   // right to left but in the vector they're ordered left to right.
   for (ContentSettingViews::const_reverse_iterator
        i(content_setting_views_.rbegin()); i != content_setting_views_.rend();
        ++i) {
-    if ((*i)->IsVisible()) {
+    if ((*i)->visible()) {
       int content_blocked_width = (*i)->GetPreferredSize().width();
       offset -= content_blocked_width;
       (*i)->SetBounds(offset, location_y, content_blocked_width,
                       location_height);
       offset -= kItemPadding;
     }
   }
 
   // Now lay out items to the left of the edit field.
-  if (location_icon_view_->IsVisible()) {
+  if (location_icon_view_->visible()) {
     location_icon_view_->SetBounds(kEdgeThickness + kEdgeItemPadding,
         location_y, location_icon_width, location_height);
     offset = location_icon_view_->bounds().right() + kItemEditPadding;
-  } else if (ev_bubble_view_->IsVisible()) {
+  } else if (ev_bubble_view_->visible()) {
     ev_bubble_view_->SetBounds(kEdgeThickness + kBubbleHorizontalPadding,
         location_y + kBubbleVerticalPadding, ev_bubble_width,
         ev_bubble_view_->GetPreferredSize().height());
     offset = ev_bubble_view_->bounds().right() + kItemEditPadding;
   } else {
     offset = kEdgeThickness +
         (show_selected_keyword ? kBubbleHorizontalPadding : kEdgeEditPadding);
   }
 
   // Now lay out the edit field and views that autocollapse to give it more
   // room.
   gfx::Rect location_bounds(offset, location_y, entry_width, location_height);
   if (show_selected_keyword) {
     selected_keyword_view_->SetBounds(0, location_y + kBubbleVerticalPadding,
         0, selected_keyword_view_->GetPreferredSize().height());
     LayoutView(selected_keyword_view_, kItemEditPadding, available_width,
                true, &location_bounds);
-    location_bounds.set_x(selected_keyword_view_->IsVisible() ?
+    location_bounds.set_x(selected_keyword_view_->visible() ?
         (offset + selected_keyword_view_->width() + kItemEditPadding) :
         (kEdgeThickness + kEdgeEditPadding));
   } else if (show_keyword_hint) {
     keyword_hint_view_->SetBounds(0, location_y, 0, location_height);
     // Tricky: |entry_width| has already been enlarged by |kEditInternalSpace|.
     // But if we add a trailing view, it needs to have that enlargement be to
     // its left.  So we undo the enlargement, then include it in the padding for
     // the added view.
     location_bounds.Inset(0, 0, kEditInternalSpace, 0);
     LayoutView(keyword_hint_view_, kItemEditPadding, available_width, false,
                &location_bounds);
-    if (!keyword_hint_view_->IsVisible()) {
+    if (!keyword_hint_view_->visible()) {
       // Put back the enlargement that we undid above.
       location_bounds.Inset(0, 0, -kEditInternalSpace, 0);
     }
   }
 
 #if defined(OS_WIN)
   // Layout out the suggested text view right aligned to the location
   // entry. Only show the suggested text if we can fit the text from one
   // character before the end of the selection to the end of the text and the
   // suggested text. If we can't it means either the suggested text is too big,
@@ skipping 223 matching lines @@
                                  int padding,
                                  int available_width,
                                  bool leading,
                                  gfx::Rect* bounds) {
   DCHECK(view && bounds);
   gfx::Size view_size = view->GetPreferredSize();
   if ((view_size.width() + padding) > available_width)
     view_size = view->GetMinimumSize();
   int desired_width = view_size.width() + padding;
   view->SetVisible(desired_width < bounds->width());
-  if (view->IsVisible()) {
+  if (view->visible()) {
     view->SetBounds(
         leading ? bounds->x() : (bounds->right() - view_size.width()),
         view->y(), view_size.width(), view->height());
     bounds->set_width(bounds->width() - desired_width);
   }
 }
 
 void LocationBarView::RefreshContentSettingViews() {
   for (ContentSettingViews::const_iterator i(content_setting_views_.begin());
        i != content_setting_views_.end(); ++i) {
@@ skipping 13 matching lines @@
   if (mode_ != NORMAL)
     return;
 
   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)->IsVisible();
+    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 (size_t i = 0; i < service->extensions()->size(); ++i) {
     if (service->extensions()->at(i)->page_action())
       page_actions.push_back(service->extensions()->at(i)->page_action());
   }
 
   // On startup we sometimes haven't loaded any extensions. This makes sure
@@ skipping 18 matching lines @@
     GURL url = GURL(WideToUTF8(model_->GetText()));
 
     for (PageActionViews::const_iterator i(page_action_views_.begin());
          i != page_action_views_.end(); ++i) {
       (*i)->UpdateVisibility(model_->input_in_progress() ? NULL : 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)->IsVisible()) {
+          old_visibility[action] != (*i)->visible()) {
         NotificationService::current()->Notify(
             NotificationType::EXTENSION_PAGE_ACTION_VISIBILITY_CHANGED,
             Source<ExtensionAction>(action),
             Details<TabContents>(contents));
       }
     }
   }
 }
 
 #if defined(OS_WIN)
@@ skipping 31 matching lines @@
 }
 
 bool LocationBarView::SkipDefaultKeyEventProcessing(
     const views::KeyEvent& event) {
 #if defined(OS_WIN)
   if (views::FocusManager::IsTabTraversalKeyEvent(event)) {
     if (HasValidSuggestText()) {
       // Return true so that the edit sees the tab and commits the suggestion.
       return true;
     }
-    if (keyword_hint_view_->IsVisible() && !event.IsShiftDown()) {
+    if (keyword_hint_view_->visible() && !event.IsShiftDown()) {
       // Return true so the edit gets the tab event and enters keyword mode.
       return true;
     }
 
     // If the caret is not at the end, then tab moves the caret to the end.
     if (!location_entry_->IsCaretAtEnd())
       return true;
 
     // Tab while showing instant commits instant immediately.
     // Return true so that focus traversal isn't attempted. The edit ends
@@ skipping 120 matching lines @@
   return this;
 }
 
 int LocationBarView::PageActionCount() {
   return page_action_views_.size();
 }
 
 int LocationBarView::PageActionVisibleCount() {
   int result = 0;
   for (size_t i = 0; i < page_action_views_.size(); i++) {
-    if (page_action_views_[i]->IsVisible())
+    if (page_action_views_[i]->visible())
       ++result;
   }
   return result;
 }
 
 ExtensionAction* LocationBarView::GetPageAction(size_t index) {
   if (index < page_action_views_.size())
     return page_action_views_[index]->image_view()->page_action();
 
   NOTREACHED();
   return NULL;
 }
 
 ExtensionAction* LocationBarView::GetVisiblePageAction(size_t index) {
   size_t current = 0;
   for (size_t i = 0; i < page_action_views_.size(); ++i) {
-    if (page_action_views_[i]->IsVisible()) {
+    if (page_action_views_[i]->visible()) {
       if (current == index)
         return page_action_views_[i]->image_view()->page_action();
 
       ++current;
     }
   }
 
   NOTREACHED();
   return NULL;
 }
 
 void LocationBarView::TestPageActionPressed(size_t index) {
   size_t current = 0;
   for (size_t i = 0; i < page_action_views_.size(); ++i) {
-    if (page_action_views_[i]->IsVisible()) {
+    if (page_action_views_[i]->visible()) {
       if (current == index) {
         const int kLeftMouseButton = 1;
         page_action_views_[i]->image_view()->ExecuteAction(kLeftMouseButton,
             false);  // inspect_with_devtools
         return;
       }
       ++current;
     }
   }
 
@@ skipping 18 matching lines @@
       Update(NULL);
   }
 }
 
 #if defined(OS_WIN)
 bool LocationBarView::HasValidSuggestText() const {
   return suggested_text_view_ && !suggested_text_view_->size().IsEmpty() &&
       !suggested_text_view_->GetText().empty();
 }
 #endif