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

ui/aura/window_targeter.cc

Index: ui/aura/window_targeter.cc
diff --git a/ui/aura/window_targeter.cc b/ui/aura/window_targeter.cc
index 9853585d3cda3a6a0dddb1503f668abb4b34c7d5..4802b3c32d9086bbc6ddb5f3b72ad78f8a883d22 100644
--- a/ui/aura/window_targeter.cc
+++ b/ui/aura/window_targeter.cc
@@ -4,6 +4,8 @@
 
 #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"
@@ -15,6 +17,7 @@
 #include "ui/events/event_target_iterator.h"
 
 namespace aura {
+const char kHasIndependentBoundsKey[] = "__INDEPENDENT_BOUNDS__";
 
 WindowTargeter::WindowTargeter() {}
 WindowTargeter::~WindowTargeter() {}
@@ -59,6 +62,48 @@ bool WindowTargeter::EventLocationInsideBounds(
   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);
@@ -99,8 +144,9 @@ ui::EventTarget* WindowTargeter::FindNextBestTarget(
 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,