Dragging within the popup window of the omnibar didn't result in the desired ...

chrome/browser/views/autocomplete/autocomplete_popup_contents_view.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved. Use of this
+// Copyright (c) 2010 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/views/autocomplete/autocomplete_popup_contents_view.h"
 
 #include "app/bidi_line_iterator.h"
 #include "app/gfx/canvas.h"
 #include "app/gfx/color_utils.h"
 #include "app/gfx/insets.h"
 #include "app/gfx/path.h"
@@ skipping 105 matching lines @@
 
   // Updates the match used to paint the contents of this result view. We copy
   // the match so that we can continue to paint the last result even after the
   // model has changed.
   void set_match(const AutocompleteMatch& match) { match_ = match; }
 
   // Overridden from views::View:
   virtual void Paint(gfx::Canvas* canvas);
   virtual void Layout();
   virtual gfx::Size GetPreferredSize();
-  virtual void OnMouseEntered(const views::MouseEvent& event);
-  virtual void OnMouseMoved(const views::MouseEvent& event);
-  virtual void OnMouseExited(const views::MouseEvent& event);
-  virtual bool OnMousePressed(const views::MouseEvent& event);
-  virtual void OnMouseReleased(const views::MouseEvent& event, bool canceled);
-  virtual bool OnMouseDragged(const views::MouseEvent& event);
 
  private:
   ResultViewState GetState() const;
 
   SkBitmap* GetIcon() const;
 
   // Draws the specified |text| into the canvas, using highlighting provided by
   // |classifications|. If |force_dim| is true, ACMatchClassification::DIM is
   // added to all of the classifications. Returns the x position to the right
   // of the string.
@@ skipping 236 matching lines @@
       std::max(0, bounds().right() - text_x - kRowRightPadding),
       font_.height());
 }
 
 gfx::Size AutocompleteResultView::GetPreferredSize() {
   int text_height = font_.height() + 2 * kTextVerticalPadding;
   int icon_height = icon_size_ + 2 * kIconVerticalPadding;
   return gfx::Size(0, std::max(icon_height, text_height));
 }
 
-void AutocompleteResultView::OnMouseEntered(const views::MouseEvent& event) {
-  model_->SetHoveredLine(model_index_);
-}
-
-void AutocompleteResultView::OnMouseMoved(const views::MouseEvent& event) {
-  model_->SetHoveredLine(model_index_);
-  if (event.IsLeftMouseButton())
-    model_->SetSelectedLine(model_index_, false);
-}
-
-void AutocompleteResultView::OnMouseExited(const views::MouseEvent& event) {
-  model_->SetHoveredLine(AutocompletePopupModel::kNoMatch);
-}
-
-bool AutocompleteResultView::OnMousePressed(const views::MouseEvent& event) {
-  if (event.IsLeftMouseButton() || event.IsMiddleMouseButton()) {
-    model_->SetHoveredLine(model_index_);
-    if (event.IsLeftMouseButton())
-      model_->SetSelectedLine(model_index_, false);
-  }
-  return true;
-}
-
-void AutocompleteResultView::OnMouseReleased(const views::MouseEvent& event,
-                                             bool canceled) {
-  if (canceled)
-    return;
-  if (event.IsOnlyMiddleMouseButton())
-    model_->OpenIndex(model_index_, NEW_BACKGROUND_TAB);
-  else if (event.IsOnlyLeftMouseButton())
-    model_->OpenIndex(model_index_, CURRENT_TAB);
-}
-
-bool AutocompleteResultView::OnMouseDragged(const views::MouseEvent& event) {
-  // TODO(beng): move all message handling into the contents view and override
-  //             GetViewForPoint.
-  return false;
-}
 
 ResultViewState AutocompleteResultView::GetState() const {
   if (model_->IsSelectedIndex(model_index_))
     return SELECTED;
   return model_->IsHoveredIndex(model_index_) ? HOVERED : NORMAL;
 }
 
 SkBitmap* AutocompleteResultView::GetIcon() const {
   bool selected = model_->IsSelectedIndex(model_index_);
   if (match_.starred)
@@ skipping 274 matching lines @@
 // AutocompletePopupContentsView, AutocompleteResultViewModel implementation:
 
 bool AutocompletePopupContentsView::IsSelectedIndex(size_t index) const {
   return HasMatchAt(index) ? index == model_->selected_line() : false;
 }
 
 bool AutocompletePopupContentsView::IsHoveredIndex(size_t index) const {
   return HasMatchAt(index) ? index == model_->hovered_line() : false;
 }
 
-void AutocompletePopupContentsView::OpenIndex(
-    size_t index,
-    WindowOpenDisposition disposition) {
-  if (!HasMatchAt(index))
-    return;
-
-  const AutocompleteMatch& match = model_->result().match_at(index);
-  // OpenURL() may close the popup, which will clear the result set and, by
-  // extension, |match| and its contents.  So copy the relevant strings out to
-  // make sure they stay alive until the call completes.
-  const GURL url(match.destination_url);
-  std::wstring keyword;
-  const bool is_keyword_hint = model_->GetKeywordForMatch(match, &keyword);
-  edit_view_->OpenURL(url, disposition, match.transition, GURL(), index,
-                      is_keyword_hint ? std::wstring() : keyword);
-}
-
-void AutocompletePopupContentsView::SetHoveredLine(size_t index) {
-  if (HasMatchAt(index))
-    model_->SetHoveredLine(index);
-}
-
-void AutocompletePopupContentsView::SetSelectedLine(size_t index,
-                                                    bool revert_to_default) {
-  if (HasMatchAt(index))
-    model_->SetSelectedLine(index, revert_to_default);
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // AutocompletePopupContentsView, AnimationDelegate implementation:
 
 void AutocompletePopupContentsView::AnimationProgressed(
     const Animation* animation) {
   // We should only be running the animation when the popup is already visible.
   DCHECK(popup_ != NULL);
   popup_->SetBounds(GetPopupBounds());
 }
 
@@ skipping 53 matching lines @@
     v->SetBounds(contents_rect.x(), top, contents_rect.width(),
                  v->GetPreferredSize().height());
     top = v->bounds().bottom();
   }
 
   // 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();
 }
 
+
+void AutocompletePopupContentsView::OnMouseEntered(
+    const views::MouseEvent& event) {
+  model_->SetHoveredLine(GetIndexForPoint(event.location()));
+}
+
+void AutocompletePopupContentsView::OnMouseMoved(
+    const views::MouseEvent& event) {
+  model_->SetHoveredLine(GetIndexForPoint(event.location()));
+}
+
+void AutocompletePopupContentsView::OnMouseExited(
+    const views::MouseEvent& event) {
+  model_->SetHoveredLine(AutocompletePopupModel::kNoMatch);
+}
+
+bool AutocompletePopupContentsView::OnMousePressed(
+    const views::MouseEvent& event) {
+  if (event.IsLeftMouseButton() || event.IsMiddleMouseButton()) {
+    int index = GetIndexForPoint(event.location());
+    model_->SetHoveredLine(index);
+    if (HasMatchAt(index) && event.IsLeftMouseButton())
+      model_->SetSelectedLine(index, false);
+  }
+  return true;
+}
+
+void AutocompletePopupContentsView::OnMouseReleased(
+    const views::MouseEvent& event,
+    bool canceled) {
+  if (canceled)
+    return;
+  int index = GetIndexForPoint(event.location());
+  if (index == AutocompletePopupModel::kNoMatch)
+    return;
+  if (event.IsOnlyMiddleMouseButton())
+    OpenIndex(index, NEW_BACKGROUND_TAB);
+  else if (event.IsOnlyLeftMouseButton())
+    OpenIndex(index, CURRENT_TAB);
+}
+
+bool AutocompletePopupContentsView::OnMouseDragged(
+    const views::MouseEvent& event) {
+  if (event.IsLeftMouseButton() || event.IsMiddleMouseButton()) {
+    int index = GetIndexForPoint(event.location());
+    model_->SetHoveredLine(index);
+    if (HasMatchAt(index) && event.IsLeftMouseButton())
+      model_->SetSelectedLine(index, false);
+  }
+  return true;
+}
+
+views::View* AutocompletePopupContentsView::GetViewForPoint(
+    const gfx::Point& /*point*/) {
+  // This View takes control of the mouse events, so it should be considered the
+  // active view for any point inside of it.
+  return this;
+}
+
+
 ////////////////////////////////////////////////////////////////////////////////
 // AutocompletePopupContentsView, private:
 
 bool AutocompletePopupContentsView::HasMatchAt(size_t index) const {
   return index < model_->result().size();
 }
 
 const AutocompleteMatch& AutocompletePopupContentsView::GetMatchAtIndex(
     size_t index) const {
   return model_->result().match_at(index);
@@ skipping 42 matching lines @@
 
 void AutocompletePopupContentsView::MakeCanvasTransparent(
     gfx::Canvas* canvas) {
   // Allow the window blur effect to show through the popup background.
   SkAlpha alpha = GetThemeProvider()->ShouldUseNativeFrame() ?
       kGlassPopupAlpha : kOpaquePopupAlpha;
   canvas->drawColor(SkColorSetA(GetColor(NORMAL, BACKGROUND), alpha),
                     SkXfermode::kDstIn_Mode);
 }
 
+void AutocompletePopupContentsView::OpenIndex(
+    size_t index,
+    WindowOpenDisposition disposition) {
+  if (!HasMatchAt(index))
+    return;
+
+  const AutocompleteMatch& match = model_->result().match_at(index);
+  // OpenURL() may close the popup, which will clear the result set and, by
+  // extension, |match| and its contents.  So copy the relevant strings out to
+  // make sure they stay alive until the call completes.
+  const GURL url(match.destination_url);
+  std::wstring keyword;
+  const bool is_keyword_hint = model_->GetKeywordForMatch(match, &keyword);
+  edit_view_->OpenURL(url, disposition, match.transition, GURL(), index,
+                      is_keyword_hint ? std::wstring() : keyword);
+}
+
+int AutocompletePopupContentsView::GetIndexForPoint(const gfx::Point& point) {
+  if (!HitTest(point))
+    return AutocompletePopupModel::kNoMatch;
+
+  int nb_match = model_->result().size();
+  DCHECK(nb_match <= GetChildViewCount());
+  for (int i = 0; i < nb_match; ++i) {
+    views::View* child = GetChildViewAt(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;
+}
+
 // static
 AutocompletePopupView* AutocompletePopupView::CreatePopupView(
     const gfx::Font& font,
     AutocompleteEditView* edit_view,
     AutocompleteEditModel* edit_model,
     Profile* profile,
     const BubblePositioner* bubble_positioner) {
   return new AutocompletePopupContentsView(font, edit_view, edit_model,
                                            profile, bubble_positioner);
 }