Created min size for print preview dialog and modified to allow the

ui/aura/window_targeter.cc

 // Copyright (c) 2013 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 "ui/aura/window_targeter.h"
 
+#include <memory>
+
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/event_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/events/event_target.h"
 #include "ui/events/event_target_iterator.h"
 
 namespace aura {
+const char kHasIndependentBoundsKey[] = "__INDEPENDENT_BOUNDS__";
 
 WindowTargeter::WindowTargeter() {}
 WindowTargeter::~WindowTargeter() {}
 
 Window* WindowTargeter::FindTargetForLocatedEvent(Window* window,
                                                   ui::LocatedEvent* event) {
   if (!window->parent()) {
     Window* target = FindTargetInRootWindow(window, *event);
     if (target) {
       window->ConvertEventToTarget(target, event);
@@ skipping 24 matching lines @@
 
 bool WindowTargeter::EventLocationInsideBounds(
     Window* window,
     const ui::LocatedEvent& event) const {
   gfx::Point point = event.location();
   if (window->parent())
     Window::ConvertPointToTarget(window->parent(), window, &point);
   return gfx::Rect(window->bounds().size()).Contains(point);
 }
 
+bool WindowTargeter::ChildHasBoundsOutsideParent(Window* parent,
+                                                 Window* child) {
+  if (!parent || !child)
+    return false;
+  return !!child->GetNativeWindowProperty(aura::kHasIndependentBoundsKey);
+}
+
+bool WindowTargeter::HasIndependentChildWithEvent(Window* window,
+                                                  const gfx::Point& event_point,
+                                                  bool in_parent_coordinates) {
+  gfx::Point point(event_point);
+  Window* parent = window->parent();
+  bool can_accept = true;
+  if (parent) {
+    if (!in_parent_coordinates)
+      Window::ConvertPointToTarget(window, parent, &point);
+    if (parent->delegate_ &&
+        !parent->delegate_->ShouldDescendIntoChildForEventHandling(window,
+                                                                   point)) {
+      can_accept = false;
+    }
+    Window::ConvertPointToTarget(parent, window, &point);
+  }
+  bool in_bounds = gfx::Rect(window->bounds().size()).Contains(point);
+  can_accept = can_accept && (window->IsVisible() && !window->ignore_events());
+  client::EventClient* client = client::GetEventClient(window->GetRootWindow());
+  if (client && !client->CanProcessEventsWithinSubtree(window))
+    can_accept = false;
+  if (in_bounds && can_accept && ChildHasBoundsOutsideParent(parent, window))
+    return true;
+  std::unique_ptr<ui::EventTargetIterator> iter = window->GetChildIterator();
+  if (iter) {
+    for (ui::EventTarget* child = iter->GetNextTarget(); child;
+         child = iter->GetNextTarget()) {
+      if (HasIndependentChildWithEvent(static_cast<Window*>(child), point,
+                                       true))
+        return true;
+    }
+  }
+  return false;
+}
+
 ui::EventTarget* WindowTargeter::FindTargetForEvent(ui::EventTarget* root,
                                                     ui::Event* event) {
   Window* window = static_cast<Window*>(root);
   Window* target = event->IsKeyEvent()
                        ? FindTargetForKeyEvent(window, *event->AsKeyEvent())
                        : FindTargetForNonKeyEvent(window, event);
   if (target && !window->parent() && !window->Contains(target)) {
     // |window| is the root window, but |target| is not a descendent of
     // |window|. So do not allow dispatching from here. Instead, dispatch the
     // event through the WindowEventDispatcher that owns |target|.
@@ skipping 20 matching lines @@
 
 ui::EventTarget* WindowTargeter::FindNextBestTarget(
     ui::EventTarget* previous_target,
     ui::Event* event) {
   return nullptr;
 }
 
 bool WindowTargeter::SubtreeShouldBeExploredForEvent(
     Window* window,
     const ui::LocatedEvent& event) {
-  return SubtreeCanAcceptEvent(window, event) &&
-         EventLocationInsideBounds(window, event);
+  return (SubtreeCanAcceptEvent(window, event) &&
+          EventLocationInsideBounds(window, event)) ||
+         HasIndependentChildWithEvent(window, event.location(), true);
 }
 
 Window* WindowTargeter::FindTargetForKeyEvent(Window* window,
                                               const ui::KeyEvent& key) {
   Window* root_window = window->GetRootWindow();
   client::FocusClient* focus_client = client::GetFocusClient(root_window);
   if (!focus_client)
     return window;
   Window* focused_window = focus_client->GetFocusedWindow();
   if (!focused_window)
@@ skipping 76 matching lines @@
           static_cast<Window*>(targeter->FindTargetForEvent(child, event));
       if (child_target_window)
         return child_target_window;
     }
     target->ConvertEventToTarget(root_window, event);
   }
   return root_window->CanAcceptEvent(*event) ? root_window : nullptr;
 }
 
 }  // namespace aura