Solved 2 bugs which caused Chrome to maximize itself when...

chrome/views/root_view.cc

 // Copyright (c) 2006-2008 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/views/root_view.h"
 
 #include <algorithm>
 
 #if defined(OS_WIN)
 #include "base/base_drag_source.h"
@@ skipping 247 matching lines @@
         Source<View>(child),
         Details<View>(parent));
   }
 }
 
 void RootView::SetFocusOnMousePressed(bool f) {
   focus_on_mouse_pressed_ = f;
 }
 
 bool RootView::OnMousePressed(const MouseEvent& e) {
+  static View* last_click_handler = 0;
+
+  // This function is not to handle non-client messages, so we return that
+  // we are not handling it quickly except for the double-click because we
+  // need to absorb it when it occurs on a different view than its single
+  // click part.
+  if ((e.GetFlags() & MouseEvent::EF_IS_NON_CLIENT) &&
+      !(e.GetFlags() & MouseEvent::EF_IS_DOUBLE_CLICK)) {
+    last_click_handler = 0;
+    return false;
+  }
+
   UpdateCursor(e);
-
   SetMouseLocationAndFlags(e);
 
   // If mouse_pressed_handler_ is non null, we are currently processing
   // a pressed -> drag -> released session. In that case we send the
   // event to mouse_pressed_handler_
   if (mouse_pressed_handler_) {
     MouseEvent mouse_pressed_event(e, this, mouse_pressed_handler_);
     drag_info.Reset();
     mouse_pressed_handler_->ProcessMousePressed(mouse_pressed_event,
                                                 &drag_info);
     return true;
   }
   DCHECK(!explicit_mouse_handler_);
 
   bool hit_disabled_view = false;
   // Walk up the tree until we find a view that wants the mouse event.
   for (mouse_pressed_handler_ = GetViewForPoint(e.location());
        mouse_pressed_handler_ && (mouse_pressed_handler_ != this);
        mouse_pressed_handler_ = mouse_pressed_handler_->GetParent()) {
     if (!mouse_pressed_handler_->IsEnabled()) {
       // Disabled views should eat events instead of propagating them upwards.
       hit_disabled_view = true;
       break;
     }
 
     // See if this view wants to handle the mouse press.
     const MouseEvent mouse_pressed_event(e, this, mouse_pressed_handler_);
     drag_info.Reset();
     const bool handled =
+        (!(e.GetFlags() & MouseEvent::EF_IS_DOUBLE_CLICK) ||
+        (mouse_move_handler_ == last_click_handler)) &&
         mouse_pressed_handler_->ProcessMousePressed(mouse_pressed_event,
                                                     &drag_info);
 
     // The view could have removed itself from the tree when handling
     // OnMousePressed().  In this case, the removal notification will have
     // reset mouse_pressed_handler_ to NULL out from under us.  Detect this
     // case and stop.  (See comments in view.h.)
     //
     // NOTE: Don't return true here, because we don't want the frame to
     // forward future events to us when there's no handler.
     if (!mouse_pressed_handler_)
       break;
 
     // If the view handled the event, leave mouse_pressed_handler_ set and
     // return true, which will cause subsequent drag/release events to get
     // forwarded to that view.
-    if (handled)
+    if (handled) {
+      last_click_handler = mouse_pressed_handler_;
       return true;
+    }
   }
 
   // Reset mouse_pressed_handler_ to indicate that no processing is occurring.
   mouse_pressed_handler_ = NULL;
 
   if (focus_on_mouse_pressed_) {
 #if defined(OS_WIN)
     HWND hwnd = GetWidget()->GetHWND();
     if (::GetFocus() != hwnd) {
       ::SetFocus(hwnd);
     }
 #else
     NOTIMPLEMENTED();
 #endif
   }
+
+  // If we go through the whole hierarchy and we did not find the same handler
+  // for the double-click as we did for the single-click, then mark it as
+  // handled to eat up any double-click that ends up in a different location
+  // than its single-click part.
+  if (last_click_handler && e.GetFlags() & MouseEvent::EF_IS_DOUBLE_CLICK)
+    hit_disabled_view = true;
+
+  last_click_handler = 0;
   return hit_disabled_view;
 }
 
 bool RootView::ConvertPointToMouseHandler(const gfx::Point& l,
                                           gfx::Point* p) {
   //
   // If the mouse_handler was set explicitly, we need to keep
   // sending events even if it was reparented in a different
   // window. (a non explicit mouse handler is automatically
   // cleared when the control is removed from the hierarchy)
@@ skipping 607 matching lines @@
 void RootView::SetAccessibleName(const std::wstring& name) {
   accessible_name_.assign(name);
 }
 
 View* RootView::GetDragView() {
   return drag_view_;
 }
 
 }  // namespace views