Allow setting different hit test bounds overrides for mouse and touch

ash/wm/window_state.cc

 // Copyright 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 "ash/wm/window_state.h"
 
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_properties.h"
@@ skipping 10 matching lines @@
 namespace wm {
 
 // static
 bool WindowState::IsMaximizedOrFullscreenState(ui::WindowShowState show_state) {
   return show_state == ui::SHOW_STATE_FULLSCREEN ||
       show_state == ui::SHOW_STATE_MAXIMIZED;
 }
 
 WindowState::WindowState(aura::Window* window)
     : window_(window),
+      fullscreen_type_(FULLSCREEN_TYPE_OTHER),
       tracked_by_workspace_(true),
       window_position_managed_(false),
       bounds_changed_by_user_(false),
       panel_attached_(true),
       continue_drag_after_reparent_(false),
       ignored_by_shelf_(false),
       can_consume_system_keys_(false),
       top_row_keys_are_function_keys_(false),
       always_restores_to_restore_bounds_(false),
       window_show_type_(ToWindowShowType(GetShowState())) {
@@ skipping 12 matching lines @@
 }
 
 bool WindowState::IsMaximized() const {
   return GetShowState() == ui::SHOW_STATE_MAXIMIZED;
 }
 
 bool WindowState::IsFullscreen() const {
   return GetShowState() == ui::SHOW_STATE_FULLSCREEN;
 }
 
+bool WindowState::IsImmersiveFullscreen() const {
+  if (!IsFullscreen())
+    return false;
+  return fullscreen_type_ == FULLSCREEN_TYPE_IMMERSIVE_MINIMAL_CHROME ||
+      fullscreen_type_ == FULLSCREEN_TYPE_IMMERSIVE_NO_CHROME;
+}
+
 bool WindowState::IsMaximizedOrFullscreen() const {
   return IsMaximizedOrFullscreenState(GetShowState());
 }
 
 bool WindowState::IsNormalShowState() const {
   ui::WindowShowState state = window_->GetProperty(aura::client::kShowStateKey);
   return state == ui::SHOW_STATE_NORMAL || state == ui::SHOW_STATE_DEFAULT;
 }
 
 bool WindowState::IsActive() const {
@@ skipping 111 matching lines @@
 
 void WindowState::SetRestoreBoundsInParent(const gfx::Rect& bounds) {
   SetRestoreBoundsInScreen(
       ScreenAsh::ConvertRectToScreen(window_->parent(), bounds));
 }
 
 void WindowState::ClearRestoreBounds() {
   window_->ClearProperty(aura::client::kRestoreBoundsKey);
 }
 
+void WindowState::SetFullscreenType(FullscreenType type) {

[James Cook, 2013/10/17 16:56:24]

Do you need to be able to change the fullscreen type even when you are not in
fullscreen?  If not, it might be clearer to require IsFullscreen() to make these
changes, either by returning early or DCHECK(IsFullScreen()). This would also
make it more clear about when ShowType change notifications happen vs.
FullscreenType change notifications.

If it has to be this way I might document why the notification pattern for
OnWindowFullscreenTypeChanged() has to be the way it is, maybe in the header.

[pkotwicz, 2013/10/17 22:14:27]

I now ignore calls to SetFullscreenType() when not in fullscreen.
However, in order to accomodate the new behavior, I have to reset
|fullscreen_type_| in OnWindowPropertyChanged().
I think this way is slightly easier to understand.

+  if (fullscreen_type_ == type)
+    return;
+  FullscreenType old = fullscreen_type_;
+  fullscreen_type_ = type;
+  if (IsFullscreen()) {
+    FOR_EACH_OBSERVER(WindowStateObserver, observer_list_,
+                      OnWindowFullscreenTypeChanged(this, old));
+  }
+}
+
 void WindowState::SetPreAutoManageWindowBounds(
     const gfx::Rect& bounds) {
   pre_auto_manage_window_bounds_.reset(new gfx::Rect(bounds));
 }
 
 void WindowState::AddObserver(WindowStateObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void WindowState::RemoveObserver(WindowStateObserver* observer) {
@@ skipping 65 matching lines @@
   }
   return settings;
 }
 
 const WindowState* GetWindowState(const aura::Window* window) {
   return GetWindowState(const_cast<aura::Window*>(window));
 }
 
 }  // namespace wm
 }  // namespace ash