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"
 
@@ skipping 35 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::EventLocationInsideBoundsRecursive(Window* window,
+                                                        gfx::Point point,
+                                                        gfx::Point location) {
+  Window* parent = window->parent();
+  bool canAccept = true;
+  if (parent) {
+    if (parent->delegate_ &&
+        !parent->delegate_->ShouldDescendIntoChildForEventHandling(window,
+                                                                   location)) {
+      canAccept = false;
+    }
+    Window::ConvertPointToTarget(window->parent(), window, &point);
+  }
+
+  bool inBounds = gfx::Rect(window->bounds().size()).Contains(point);
+  canAccept = canAccept && (window->IsVisible() && !window->ignore_events());
+  client::EventClient* client = client::GetEventClient(window->GetRootWindow());
+  if (client && !client->CanProcessEventsWithinSubtree(window))
+    canAccept = false;
+  if (inBounds && canAccept) {
+    return true;
+  }
+  std::unique_ptr<ui::EventTargetIterator> iter = window->GetChildIterator();
+  if (iter) {
+    for (ui::EventTarget* child = iter->GetNextTarget(); child;
+         child = iter->GetNextTarget()) {
+      if (EventLocationInsideBoundsRecursive(static_cast<Window*>(child), point,
+                                             location))
+        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 21 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);
+         EventLocationInsideBoundsRecursive(window, event.location(),
+                                            event.location());
 }
 
 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