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

ui/wm/core/focus_controller.cc

 // Copyright (c) 2012 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/wm/core/focus_controller.h"
 
 #include "base/auto_reset.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/focus_change_observer.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/events/event.h"
 #include "ui/wm/core/focus_rules.h"
+#include "ui/wm/core/window_modality_controller.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/public/activation_change_observer.h"
 
 namespace wm {
 namespace {
 
 // When a modal window is activated, we bring its entire transient parent chain
 // to the front. This function must be called before the modal transient is
 // stacked at the top to ensure correct stacking order.
 void StackTransientParentsBelowModalWindow(aura::Window* window) {
@@ skipping 157 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // FocusController, private:
 
 void FocusController::FocusAndActivateWindow(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* window) {
   if (window &&
       (window->Contains(focused_window_) || window->Contains(active_window_))) {
     StackActiveWindow();
-    return;
+    if (HasWindowModalTransient(window) && active_window_ == window)
+      // Trying to reactivate the window, need to activate the transient first
+      ActivateWindow(HasWindowModalTransient(window));
+    else
+      return;
   }
 
   // Focusing a window also activates its containing activatable window. Note
   // that the rules could redirect activation activation and/or focus.
   aura::Window* focusable = rules_->GetFocusableWindow(window);
   aura::Window* activatable =
       focusable ? rules_->GetActivatableWindow(focusable) : NULL;
 
   // We need valid focusable/activatable windows in the event we're not clearing
   // focus. "Clearing focus" is inferred by whether or not |window| passed to
   // this function is non-NULL.
   if (window && (!focusable || !activatable))
     return;
   DCHECK((focusable && activatable) || !window);
 
   // Activation change observers may change the focused window. If this happens
   // we must not adjust the focus below since this will clobber that change.
   aura::Window* last_focused_window = focused_window_;
   if (!updating_activation_)
     SetActiveWindow(reason, window, activatable);
 
   // If the window's ActivationChangeObserver shifted focus to a valid window,
   // we don't want to focus the window we thought would be focused by default.
   bool activation_changed_focus = last_focused_window != focused_window_;
+  if ((!updating_focus_ && (!activation_changed_focus || !focused_window_)) &&
+      active_window_ && focusable &&
+      !active_window_->Contains(focusable) &&
+      (HasWindowModalTransient(active_window_) ==
+      GetToplevelWindow(window))){
+    return;
+  }
   if (!updating_focus_ && (!activation_changed_focus || !focused_window_)) {
     if (active_window_ && focusable)
       DCHECK(active_window_->Contains(focusable));
     SetFocusedWindow(focusable);
   }
 }
 
 void FocusController::SetFocusedWindow(aura::Window* window) {
   if (updating_focus_ || window == focused_window_)
     return;
@@ skipping 37 matching lines @@
   }
 }
 
 void FocusController::SetActiveWindow(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* requested_window,
     aura::Window* window) {
   if (updating_activation_)
     return;
 
-  if (window == active_window_) {
+  if (window == active_window_ && !HasWindowModalTransient(window)) {
     if (requested_window) {
       FOR_EACH_OBSERVER(aura::client::ActivationChangeObserver,
                         activation_observers_,
                         OnAttemptToReactivateWindow(requested_window,
                                                     active_window_));
     }
     return;
   }
 
   DCHECK(rules_->CanActivateWindow(window));
@@ skipping 69 matching lines @@
   // FocusWindow() will focus the topmost window, which may not be the
   // currently focused one.
   if (rules_->CanFocusWindow(GetToplevelWindow(window))) {
     FocusAndActivateWindow(
         aura::client::ActivationChangeObserver::ActivationReason::INPUT_EVENT,
         window);
   }
 }
 
 }  // namespace wm