views: Move autocomplete files into omnibox directory.

chrome/browser/ui/views/omnibox/omnibox_popup_contents_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/autocomplete/autocomplete_popup_contents_view.h"
+#include "chrome/browser/ui/views/omnibox/omnibox_popup_contents_view.h"
 
 #if defined(OS_WIN)
 #include <commctrl.h>
 #include <dwmapi.h>
 #include <objidl.h>
 #endif
 
 #include "base/compiler_specific.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_popup_model.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/ui/omnibox/omnibox_view.h"
-#include "chrome/browser/ui/views/autocomplete/autocomplete_result_view.h"
 #include "chrome/browser/ui/views/location_bar/location_bar_view.h"
-#include "chrome/browser/ui/views/autocomplete/touch_autocomplete_popup_contents_view.h"
+#include "chrome/browser/ui/views/omnibox/omnibox_result_view.h"
+#include "chrome/browser/ui/views/omnibox/touch_omnibox_popup_contents_view.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/theme_provider.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/insets.h"
@@ skipping 26 matching lines @@
 // to gfx::Font::DeriveFont.
 #if defined(OS_CHROMEOS)
 // Don't adjust the size on Chrome OS (http://crbug.com/61433).
 const int kEditFontAdjust = 0;
 #else
 const int kEditFontAdjust = -1;
 #endif
 
 }  // namespace
 
-class AutocompletePopupContentsView::AutocompletePopupWidget
+class OmniboxPopupContentsView::AutocompletePopupWidget
     : public views::Widget,
       public base::SupportsWeakPtr<AutocompletePopupWidget> {
  public:
   AutocompletePopupWidget() {}
   virtual ~AutocompletePopupWidget() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AutocompletePopupWidget);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-// AutocompletePopupContentsView, public:
+// OmniboxPopupContentsView, public:
 
-AutocompletePopupContentsView*
-    AutocompletePopupContentsView::CreateForEnvironment(
-        const gfx::Font& font,
-        OmniboxView* omnibox_view,
-        AutocompleteEditModel* edit_model,
-        views::View* location_bar) {
-  AutocompletePopupContentsView* view = NULL;
+OmniboxPopupContentsView* OmniboxPopupContentsView::CreateForEnvironment(
+    const gfx::Font& font,
+    OmniboxView* omnibox_view,
+    AutocompleteEditModel* edit_model,
+    views::View* location_bar) {
+  OmniboxPopupContentsView* view = NULL;
   if (ui::GetDisplayLayout() == ui::LAYOUT_TOUCH) {
-    view = new TouchAutocompletePopupContentsView(
+    view = new TouchOmniboxPopupContentsView(
         font, omnibox_view, edit_model, location_bar);
   } else {
-    view = new AutocompletePopupContentsView(
+    view = new OmniboxPopupContentsView(
         font, omnibox_view, edit_model, location_bar);
   }
 
   view->Init();
   return view;
 }
 
-AutocompletePopupContentsView::AutocompletePopupContentsView(
+OmniboxPopupContentsView::OmniboxPopupContentsView(
     const gfx::Font& font,
     OmniboxView* omnibox_view,
     AutocompleteEditModel* edit_model,
     views::View* location_bar)
     : model_(new AutocompletePopupModel(this, edit_model)),
       omnibox_view_(omnibox_view),
       profile_(edit_model->profile()),
       location_bar_(location_bar),
       result_font_(font.DeriveFont(kEditFontAdjust)),
       result_bold_font_(result_font_.DeriveFont(0, gfx::Font::BOLD)),
       ignore_mouse_drag_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(size_animation_(this)) {
   // The following little dance is required because set_border() requires a
   // pointer to a non-const object.
   views::BubbleBorder* bubble_border =
       new views::BubbleBorder(views::BubbleBorder::NONE,
                               views::BubbleBorder::NO_SHADOW);
   bubble_border_ = bubble_border;
   set_border(bubble_border);
   // The contents is owned by the LocationBarView.
   set_owned_by_client();
 }
 
-void AutocompletePopupContentsView::Init() {
+void OmniboxPopupContentsView::Init() {
   // This can't be done in the constructor as at that point we aren't
   // necessarily our final class yet, and we may have subclasses
   // overriding CreateResultView.
   for (size_t i = 0; i < AutocompleteResult::kMaxMatches; ++i) {
-    AutocompleteResultView* result_view =
+    OmniboxResultView* result_view =
         CreateResultView(this, i, result_font_, result_bold_font_);
     result_view->SetVisible(false);
     AddChildViewAt(result_view, static_cast<int>(i));
   }
 }
 
-AutocompletePopupContentsView::~AutocompletePopupContentsView() {
+OmniboxPopupContentsView::~OmniboxPopupContentsView() {
   // We don't need to do anything with |popup_| here.  The OS either has already
   // closed the window, in which case it's been deleted, or it will soon, in
   // which case there's nothing we need to do.
 }
 
-gfx::Rect AutocompletePopupContentsView::GetPopupBounds() const {
+gfx::Rect OmniboxPopupContentsView::GetPopupBounds() const {
   if (!size_animation_.is_animating())
     return target_bounds_;
 
   gfx::Rect current_frame_bounds = start_bounds_;
   int total_height_delta = target_bounds_.height() - start_bounds_.height();
   // Round |current_height_delta| instead of truncating so we won't leave single
   // white pixels at the bottom of the popup as long when animating very small
   // height differences.
   int current_height_delta = static_cast<int>(
       size_animation_.GetCurrentValue() * total_height_delta - 0.5);
   current_frame_bounds.set_height(
       current_frame_bounds.height() + current_height_delta);
   return current_frame_bounds;
 }
 
-void AutocompletePopupContentsView::LayoutChildren() {
+void OmniboxPopupContentsView::LayoutChildren() {
   gfx::Rect contents_rect = GetContentsBounds();
   int top = contents_rect.y();
   for (int i = 0; i < child_count(); ++i) {
     View* v = child_at(i);
     if (v->visible()) {
       v->SetBounds(contents_rect.x(), top, contents_rect.width(),
                    v->GetPreferredSize().height());
       top = v->bounds().bottom();
     }
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// AutocompletePopupContentsView, AutocompletePopupView overrides:
+// OmniboxPopupContentsView, AutocompletePopupView overrides:
 
-bool AutocompletePopupContentsView::IsOpen() const {
-  return (popup_ != NULL);
+bool OmniboxPopupContentsView::IsOpen() const {
+  return popup_ != NULL;
 }
 
-void AutocompletePopupContentsView::InvalidateLine(size_t line) {
-  AutocompleteResultView* result = static_cast<AutocompleteResultView*>(
+void OmniboxPopupContentsView::InvalidateLine(size_t line) {
+  OmniboxResultView* result = static_cast<OmniboxResultView*>(
       child_at(static_cast<int>(line)));
   result->Invalidate();
 
   if (HasMatchAt(line) && GetMatchAtIndex(line).associated_keyword.get()) {
     result->ShowKeyword(IsSelectedIndex(line) &&
         model_->selected_line_state() == AutocompletePopupModel::KEYWORD);
   }
 }
 
-void AutocompletePopupContentsView::UpdatePopupAppearance() {
+void OmniboxPopupContentsView::UpdatePopupAppearance() {
   if (model_->result().empty()) {
     // No matches, close any existing popup.
     if (popup_ != NULL) {
       size_animation_.Stop();
 
       // NOTE: Do NOT use CloseNow() here, as we may be deep in a callstack
       // triggered by the popup receiving a message (e.g. LBUTTONUP), and
       // destroying the popup would cause us to read garbage when we unwind back
       // to that level.
       popup_->Close();  // This will eventually delete the popup.
       popup_.reset();
     }
     return;
   }
 
   // Update the match cached by each row, in the process of doing so make sure
   // we have enough row views.
   size_t child_rv_count = child_count();
   const size_t result_size = model_->result().size();
   for (size_t i = 0; i < result_size; ++i) {
-    AutocompleteResultView* view = static_cast<AutocompleteResultView*>(
-        child_at(i));
+    OmniboxResultView* view = static_cast<OmniboxResultView*>(child_at(i));
     view->SetMatch(GetMatchAtIndex(i));
     view->SetVisible(true);
   }
   for (size_t i = result_size; i < child_rv_count; ++i)
     child_at(i)->SetVisible(false);
 
   gfx::Rect new_target_bounds = CalculateTargetBounds(CalculatePopupHeight());
 
   // If we're animating and our target height changes, reset the animation.
   // NOTE: If we just reset blindly on _every_ update, then when the user types
@@ skipping 37 matching lines @@
     if (target_bounds_.height() < start_bounds_.height())
       size_animation_.Show();
     else
       start_bounds_ = target_bounds_;
     popup_->SetBounds(GetPopupBounds());
   }
 
   SchedulePaint();
 }
 
-gfx::Rect AutocompletePopupContentsView::GetTargetBounds() {
+gfx::Rect OmniboxPopupContentsView::GetTargetBounds() {
   return target_bounds_;
 }
 
-void AutocompletePopupContentsView::PaintUpdatesNow() {
+void OmniboxPopupContentsView::PaintUpdatesNow() {
   // TODO(beng): remove this from the interface.
 }
 
-void AutocompletePopupContentsView::OnDragCanceled() {
+void OmniboxPopupContentsView::OnDragCanceled() {
   ignore_mouse_drag_ = true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// AutocompletePopupContentsView, AutocompleteResultViewModel implementation:
+// OmniboxPopupContentsView, OmniboxResultViewModel implementation:
 
-bool AutocompletePopupContentsView::IsSelectedIndex(size_t index) const {
+bool OmniboxPopupContentsView::IsSelectedIndex(size_t index) const {
   return index == model_->selected_line();
 }
 
-bool AutocompletePopupContentsView::IsHoveredIndex(size_t index) const {
+bool OmniboxPopupContentsView::IsHoveredIndex(size_t index) const {
   return index == model_->hovered_line();
 }
 
-const SkBitmap* AutocompletePopupContentsView::GetIconIfExtensionMatch(
+const SkBitmap* OmniboxPopupContentsView::GetIconIfExtensionMatch(
     size_t index) const {
   if (!HasMatchAt(index))
     return NULL;
   return model_->GetIconIfExtensionMatch(GetMatchAtIndex(index));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// AutocompletePopupContentsView, AnimationDelegate implementation:
+// OmniboxPopupContentsView, AnimationDelegate implementation:
 
-void AutocompletePopupContentsView::AnimationProgressed(
+void OmniboxPopupContentsView::AnimationProgressed(
     const ui::Animation* animation) {
   // We should only be running the animation when the popup is already visible.
   DCHECK(popup_ != NULL);
   popup_->SetBounds(GetPopupBounds());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// AutocompletePopupContentsView, views::View overrides:
+// OmniboxPopupContentsView, views::View overrides:
 
-void AutocompletePopupContentsView::Layout() {
+void OmniboxPopupContentsView::Layout() {
   UpdateBlurRegion();
 
   // Size our children to the available content area.
   LayoutChildren();
 
   // We need to manually schedule a paint here since we are a layered window and
   // won't implicitly require painting until we ask for one.
   SchedulePaint();
 }
 
-views::View* AutocompletePopupContentsView::GetEventHandlerForPoint(
+views::View* OmniboxPopupContentsView::GetEventHandlerForPoint(
     const gfx::Point& point) {
   return this;
 }
 
-bool AutocompletePopupContentsView::OnMousePressed(
+bool OmniboxPopupContentsView::OnMousePressed(
     const views::MouseEvent& event) {
   ignore_mouse_drag_ = false;  // See comment on |ignore_mouse_drag_| in header.
   if (event.IsLeftMouseButton() || event.IsMiddleMouseButton())
     UpdateLineEvent(event, event.IsLeftMouseButton());
   return true;
 }
 
-bool AutocompletePopupContentsView::OnMouseDragged(
+bool OmniboxPopupContentsView::OnMouseDragged(
     const views::MouseEvent& event) {
   if (event.IsLeftMouseButton() || event.IsMiddleMouseButton())
     UpdateLineEvent(event, !ignore_mouse_drag_ && event.IsLeftMouseButton());
   return true;
 }
 
-void AutocompletePopupContentsView::OnMouseReleased(
+void OmniboxPopupContentsView::OnMouseReleased(
     const views::MouseEvent& event) {
   if (ignore_mouse_drag_) {
     OnMouseCaptureLost();
     return;
   }
 
   if (event.IsOnlyMiddleMouseButton() || event.IsOnlyLeftMouseButton()) {
     OpenSelectedLine(event, event.IsOnlyLeftMouseButton() ? CURRENT_TAB :
                                                             NEW_BACKGROUND_TAB);
   }
 }
 
-void AutocompletePopupContentsView::OnMouseCaptureLost() {
+void OmniboxPopupContentsView::OnMouseCaptureLost() {
   ignore_mouse_drag_ = false;
 }
 
-void AutocompletePopupContentsView::OnMouseMoved(
+void OmniboxPopupContentsView::OnMouseMoved(
     const views::MouseEvent& event) {
   model_->SetHoveredLine(GetIndexForPoint(event.location()));
 }
 
-void AutocompletePopupContentsView::OnMouseEntered(
+void OmniboxPopupContentsView::OnMouseEntered(
     const views::MouseEvent& event) {
   model_->SetHoveredLine(GetIndexForPoint(event.location()));
 }
 
-void AutocompletePopupContentsView::OnMouseExited(
+void OmniboxPopupContentsView::OnMouseExited(
     const views::MouseEvent& event) {
   model_->SetHoveredLine(AutocompletePopupModel::kNoMatch);
 }
 
-ui::GestureStatus AutocompletePopupContentsView::OnGestureEvent(
+ui::GestureStatus OmniboxPopupContentsView::OnGestureEvent(
     const views::GestureEvent& event) {
   switch (event.type()) {
     case ui::ET_GESTURE_TAP_DOWN:
     case ui::ET_GESTURE_SCROLL_BEGIN:
     case ui::ET_GESTURE_SCROLL_UPDATE:
       UpdateLineEvent(event, true);
       break;
     case ui::ET_GESTURE_TAP:
     case ui::ET_GESTURE_SCROLL_END:
       OpenSelectedLine(event, CURRENT_TAB);
       break;
     default:
       return ui::GESTURE_STATUS_UNKNOWN;
   }
   return ui::GESTURE_STATUS_CONSUMED;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// AutocompletePopupContentsView, protected:
+// OmniboxPopupContentsView, protected:
 
-void AutocompletePopupContentsView::PaintResultViews(gfx::Canvas* canvas) {
-  canvas->DrawColor(AutocompleteResultView::GetColor(
-      AutocompleteResultView::NORMAL, AutocompleteResultView::BACKGROUND));
+void OmniboxPopupContentsView::PaintResultViews(gfx::Canvas* canvas) {
+  canvas->DrawColor(OmniboxResultView::GetColor(
+      OmniboxResultView::NORMAL, OmniboxResultView::BACKGROUND));
   View::PaintChildren(canvas);
 }
 
-int AutocompletePopupContentsView::CalculatePopupHeight() {
+int OmniboxPopupContentsView::CalculatePopupHeight() {
   DCHECK_GE(static_cast<size_t>(child_count()), model_->result().size());
   int popup_height = 0;
   for (size_t i = 0; i < model_->result().size(); ++i)
     popup_height += child_at(i)->GetPreferredSize().height();
   return popup_height;
 }
 
-AutocompleteResultView* AutocompletePopupContentsView::CreateResultView(
-    AutocompleteResultViewModel* model,
+OmniboxResultView* OmniboxPopupContentsView::CreateResultView(
+    OmniboxResultViewModel* model,
     int model_index,
     const gfx::Font& font,
     const gfx::Font& bold_font) {
-  return new AutocompleteResultView(model, model_index, font, bold_font);
+  return new OmniboxResultView(model, model_index, font, bold_font);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// AutocompletePopupContentsView, views::View overrides, protected:
+// OmniboxPopupContentsView, views::View overrides, protected:
 
-void AutocompletePopupContentsView::OnPaint(gfx::Canvas* canvas) {
+void OmniboxPopupContentsView::OnPaint(gfx::Canvas* canvas) {
   gfx::Path path;
   MakeContentsPath(&path, GetContentsBounds());
   canvas->Save();
   canvas->sk_canvas()->clipPath(path,
                                 SkRegion::kIntersect_Op,
                                 true /* doAntialias */);
   PaintResultViews(canvas);
 
   // We want the contents background to be slightly transparent so we can see
   // the blurry glass effect on DWM systems behind. We do this _after_ we paint
   // the children since they paint text, and GDI will reset this alpha data if
   // we paint text after this call.
   MakeCanvasTransparent(canvas);
   canvas->Restore();
 
   // Now we paint the border, so it will be alpha-blended atop the contents.
   // This looks slightly better in the corners than drawing the contents atop
   // the border.
   OnPaintBorder(canvas);
 }
 
-void AutocompletePopupContentsView::PaintChildren(gfx::Canvas* canvas) {
+void OmniboxPopupContentsView::PaintChildren(gfx::Canvas* canvas) {
   // We paint our children inside OnPaint().
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// AutocompletePopupContentsView, private:
+// OmniboxPopupContentsView, private:
 
-bool AutocompletePopupContentsView::HasMatchAt(size_t index) const {
+bool OmniboxPopupContentsView::HasMatchAt(size_t index) const {
   return index < model_->result().size();
 }
 
-const AutocompleteMatch& AutocompletePopupContentsView::GetMatchAtIndex(
+const AutocompleteMatch& OmniboxPopupContentsView::GetMatchAtIndex(
     size_t index) const {
   return model_->result().match_at(index);
 }
 
-void AutocompletePopupContentsView::MakeContentsPath(
+void OmniboxPopupContentsView::MakeContentsPath(
     gfx::Path* path,
     const gfx::Rect& bounding_rect) {
   SkRect rect;
   rect.set(SkIntToScalar(bounding_rect.x()),
            SkIntToScalar(bounding_rect.y()),
            SkIntToScalar(bounding_rect.right()),
            SkIntToScalar(bounding_rect.bottom()));
 
   SkScalar radius = SkIntToScalar(views::BubbleBorder::GetCornerRadius());
   path->addRoundRect(rect, radius, radius);
 }
 
-void AutocompletePopupContentsView::UpdateBlurRegion() {
+void OmniboxPopupContentsView::UpdateBlurRegion() {
 #if defined(OS_WIN) && !defined(USE_AURA)
   // We only support background blurring on Vista with Aero-Glass enabled.
   if (!views::NativeWidgetWin::IsAeroGlassEnabled() || !GetWidget())
     return;
 
   // Provide a blurred background effect within the contents region of the
   // popup.
   DWM_BLURBEHIND bb = {0};
   bb.dwFlags = DWM_BB_ENABLE | DWM_BB_BLURREGION;
   bb.fEnable = true;
 
   // Translate the contents rect into widget coordinates, since that's what
   // DwmEnableBlurBehindWindow expects a region in.
   gfx::Rect contents_rect = ConvertRectToWidget(GetContentsBounds());
   gfx::Path contents_path;
   MakeContentsPath(&contents_path, contents_rect);
   base::win::ScopedGDIObject<HRGN> popup_region;
   popup_region.Set(contents_path.CreateNativeRegion());
   bb.hRgnBlur = popup_region.Get();
   DwmEnableBlurBehindWindow(GetWidget()->GetNativeView(), &bb);
 #endif
 }
 
-void AutocompletePopupContentsView::MakeCanvasTransparent(
-    gfx::Canvas* canvas) {
+void OmniboxPopupContentsView::MakeCanvasTransparent(gfx::Canvas* canvas) {
   // Allow the window blur effect to show through the popup background.
   SkAlpha alpha = GetThemeProvider()->ShouldUseNativeFrame() ?
       kGlassPopupAlpha : kOpaquePopupAlpha;
   canvas->DrawColor(SkColorSetA(
-      AutocompleteResultView::GetColor(AutocompleteResultView::NORMAL,
-      AutocompleteResultView::BACKGROUND), alpha), SkXfermode::kDstIn_Mode);
+      OmniboxResultView::GetColor(OmniboxResultView::NORMAL,
+          OmniboxResultView::BACKGROUND), alpha), SkXfermode::kDstIn_Mode);
 }
 
-void AutocompletePopupContentsView::OpenIndex(
-    size_t index,
-    WindowOpenDisposition disposition) {
+void OmniboxPopupContentsView::OpenIndex(size_t index,
+                                         WindowOpenDisposition disposition) {
   if (!HasMatchAt(index))
     return;
 
   // OpenMatch() may close the popup, which will clear the result set and, by
   // extension, |match| and its contents.  So copy the relevant match out to
   // make sure it stays alive until the call completes.
   AutocompleteMatch match = model_->result().match_at(index);
   omnibox_view_->OpenMatch(match, disposition, GURL(), index);
 }
 
-size_t AutocompletePopupContentsView::GetIndexForPoint(
+size_t OmniboxPopupContentsView::GetIndexForPoint(
     const gfx::Point& point) {
   if (!HitTest(point))
     return AutocompletePopupModel::kNoMatch;
 
   int nb_match = model_->result().size();
   DCHECK(nb_match <= child_count());
   for (int i = 0; i < nb_match; ++i) {
     views::View* child = child_at(i);
     gfx::Point point_in_child_coords(point);
     View::ConvertPointToView(this, child, &point_in_child_coords);
     if (child->HitTest(point_in_child_coords))
       return i;
   }
   return AutocompletePopupModel::kNoMatch;
 }
 
-gfx::Rect AutocompletePopupContentsView::CalculateTargetBounds(int h) {
+gfx::Rect OmniboxPopupContentsView::CalculateTargetBounds(int h) {
   gfx::Rect location_bar_bounds(location_bar_->GetContentsBounds());
   const views::Border* border = location_bar_->border();
   if (border) {
     // Adjust for the border so that the bubble and location bar borders are
     // aligned.
     gfx::Insets insets;
     border->GetInsets(&insets);
     location_bar_bounds.Inset(insets.left(), 0, insets.right(), 0);
   } else {
     // The normal location bar is drawn using a background graphic that includes
     // the border, so we inset by enough to make the edges line up, and the
     // bubble appear at the same height as the Star bubble.
     location_bar_bounds.Inset(LocationBarView::kNormalHorizontalEdgeThickness,
                               0);
   }
   gfx::Point location_bar_origin(location_bar_bounds.origin());
   views::View::ConvertPointToScreen(location_bar_, &location_bar_origin);
   location_bar_bounds.set_origin(location_bar_origin);
   return bubble_border_->GetBounds(
       location_bar_bounds, gfx::Size(location_bar_bounds.width(), h));
 }
 
-void AutocompletePopupContentsView::UpdateLineEvent(
+void OmniboxPopupContentsView::UpdateLineEvent(
     const views::LocatedEvent& event,
     bool should_set_selected_line) {
   size_t index = GetIndexForPoint(event.location());
   model_->SetHoveredLine(index);
   if (HasMatchAt(index) && should_set_selected_line)
     model_->SetSelectedLine(index, false, false);
 }
 
-void AutocompletePopupContentsView::OpenSelectedLine(
+void OmniboxPopupContentsView::OpenSelectedLine(
     const views::LocatedEvent& event,
     WindowOpenDisposition disposition) {
   size_t index = GetIndexForPoint(event.location());
   OpenIndex(index, disposition);
 }