Improving window auto management between workspaces

chrome/browser/sessions/session_service.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 "chrome/browser/sessions/session_service.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 27 matching lines @@
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/session_storage_namespace.h"
 #include "content/public/browser/web_contents.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/browser/app_controller_mac.h"
 #endif
 
+#if defined(USE_ASH)
+#include "ash/wm/window_util.h"
+#endif
+
 using base::Time;
 using content::NavigationEntry;
 using content::WebContents;
 
 // Identifier for commands written to file.
 static const SessionCommand::id_type kCommandSetTabWindow = 0;
 // OBSOLETE Superseded by kCommandSetWindowBounds3.
 // static const SessionCommand::id_type kCommandSetWindowBounds = 1;
 static const SessionCommand::id_type kCommandSetTabIndexInWindow = 2;
 // Original kCommandTabClosed/kCommandWindowClosed. See comment in
@@ skipping 12 matching lines @@
     kCommandTabNavigationPathPrunedFromFront = 11;
 static const SessionCommand::id_type kCommandSetPinnedState = 12;
 static const SessionCommand::id_type kCommandSetExtensionAppID = 13;
 static const SessionCommand::id_type kCommandSetWindowBounds3 = 14;
 static const SessionCommand::id_type kCommandSetWindowAppName = 15;
 static const SessionCommand::id_type kCommandTabClosed = 16;
 static const SessionCommand::id_type kCommandWindowClosed = 17;
 static const SessionCommand::id_type kCommandSetTabUserAgentOverride = 18;
 static const SessionCommand::id_type kCommandSessionStorageAssociated = 19;
 static const SessionCommand::id_type kCommandSetActiveWindow = 20;
+static const SessionCommand::id_type kCommandSetWindowBounds4 = 21;
 
 // Every kWritesPerReset commands triggers recreating the file.
 static const int kWritesPerReset = 250;
 
 namespace {
 
 // The callback from GetLastSession is internally routed to SessionService
 // first and then the caller. This is done so that the SessionWindows can be
 // recreated from the SessionCommands and the SessionWindows passed to the
 // caller. The following class is used for this.
@@ skipping 33 matching lines @@
 
 struct WindowBoundsPayload3 {
   SessionID::id_type window_id;
   int32 x;
   int32 y;
   int32 w;
   int32 h;
   int32 show_state;
 };
 
+struct WindowBoundsPayload4 {
+  SessionID::id_type window_id;
+  int32 x;
+  int32 y;
+  int32 w;
+  int32 h;
+  int32 show_state;
+  bool user_has_changed_window_or_position;
+};
+
 typedef SessionID::id_type ActiveWindowPayload;
 
 struct IDAndIndexPayload {
   SessionID::id_type id;
   int32 index;
 };
 
 typedef IDAndIndexPayload TabIndexInWindowPayload;
 
 typedef IDAndIndexPayload TabNavigationPathPrunedFromBackPayload;
@@ skipping 107 matching lines @@
 }
 
 void SessionService::SetTabWindow(const SessionID& window_id,
                                   const SessionID& tab_id) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
   ScheduleCommand(CreateSetTabWindowCommand(window_id, tab_id));
 }
 
-void SessionService::SetWindowBounds(const SessionID& window_id,
-                                     const gfx::Rect& bounds,
-                                     ui::WindowShowState show_state) {
+void SessionService::SetWindowBounds(
+    const SessionID& window_id,
+    const gfx::Rect& bounds,
+    ui::WindowShowState show_state,
+    bool user_has_changed_window_or_position) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
-
-  ScheduleCommand(CreateSetWindowBoundsCommand(window_id, bounds, show_state));
+  ScheduleCommand(CreateSetWindowBoundsCommand(
+                      window_id,
+                      bounds,
+                      show_state,
+                      user_has_changed_window_or_position));
 }
 
 void SessionService::SetTabIndexInWindow(const SessionID& window_id,
                                          const SessionID& tab_id,
                                          int new_index) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
   ScheduleCommand(CreateSetTabIndexInWindowCommand(tab_id, new_index));
 }
@@ skipping 460 matching lines @@
   SessionID::id_type payload[] = { window_id.id(), tab_id.id() };
   SessionCommand* command =
       new SessionCommand(kCommandSetTabWindow, sizeof(payload));
   memcpy(command->contents(), payload, sizeof(payload));
   return command;
 }
 
 SessionCommand* SessionService::CreateSetWindowBoundsCommand(
     const SessionID& window_id,
     const gfx::Rect& bounds,
-    ui::WindowShowState show_state) {
-  WindowBoundsPayload3 payload = { 0 };
+    ui::WindowShowState show_state,
+    bool user_has_changed_window_or_position) {
+  WindowBoundsPayload4 payload = { 0 };
   payload.window_id = window_id.id();
   payload.x = bounds.x();
   payload.y = bounds.y();
   payload.w = bounds.width();
   payload.h = bounds.height();
   payload.show_state = AdjustShowState(show_state);
-  SessionCommand* command = new SessionCommand(kCommandSetWindowBounds3,
+  payload.user_has_changed_window_or_position =
+      user_has_changed_window_or_position;
+  SessionCommand* command = new SessionCommand(kCommandSetWindowBounds4,
                                                sizeof(payload));
   memcpy(command->contents(), &payload, sizeof(payload));
   return command;
 }
 
 SessionCommand* SessionService::CreateSetTabIndexInWindowCommand(
     const SessionID& tab_id,
     int new_index) {
   TabIndexInWindowPayload payload = { 0 };
   payload.id = tab_id.id();
@@ skipping 313 matching lines @@
             payload.show_state < ui::SHOW_STATE_END &&
             payload.show_state != ui::SHOW_STATE_INACTIVE) {
           show_state = static_cast<ui::WindowShowState>(payload.show_state);
         } else {
           NOTREACHED();
         }
         GetWindow(payload.window_id, windows)->show_state = show_state;
         break;
       }
 
+      case kCommandSetWindowBounds4: {
+        WindowBoundsPayload4 payload;
+        if (!command->GetPayload(&payload, sizeof(payload))) {
+          VLOG(1) << "Failed reading command " << command->id();
+          return true;
+        }
+        GetWindow(payload.window_id, windows)->bounds.SetRect(payload.x,
+                                                              payload.y,
+                                                              payload.w,
+                                                              payload.h);
+        // SHOW_STATE_INACTIVE is not persisted.
+        ui::WindowShowState show_state = ui::SHOW_STATE_NORMAL;
+        if (payload.show_state > ui::SHOW_STATE_DEFAULT &&
+            payload.show_state < ui::SHOW_STATE_END &&
+            payload.show_state != ui::SHOW_STATE_INACTIVE) {
+          show_state = static_cast<ui::WindowShowState>(payload.show_state);
+        } else {
+          NOTREACHED();
+        }
+        GetWindow(payload.window_id, windows)->show_state = show_state;
+        GetWindow(payload.window_id,
+                  windows)->user_has_changed_window_or_position =
+                      payload.user_has_changed_window_or_position;
+        break;
+      }
+
       case kCommandSetTabIndexInWindow: {
         TabIndexInWindowPayload payload;
         if (!command->GetPayload(&payload, sizeof(payload))) {
           VLOG(1) << "Failed reading command " << command->id();
           return true;
         }
         GetTab(payload.id, tabs)->tab_visual_index = payload.index;
         break;
       }
 
@@ skipping 268 matching lines @@
     std::set<SessionID::id_type>* windows_to_track) {
   DCHECK(browser && commands);
   DCHECK(browser->session_id().id());
 
   ui::WindowShowState show_state = ui::SHOW_STATE_NORMAL;
   if (browser->window()->IsMaximized())
     show_state = ui::SHOW_STATE_MAXIMIZED;
   else if (browser->window()->IsMinimized())
     show_state = ui::SHOW_STATE_MINIMIZED;
 
+  bool user_has_changed_window_or_position = false;
+#if defined(USE_ASH)
+  user_has_changed_window_or_position =
+      ash::wm::HasUserChangedWindowPositionOrSize(
+          browser->window()->GetNativeWindow());
+#endif
   commands->push_back(
       CreateSetWindowBoundsCommand(browser->session_id(),
                                    browser->window()->GetRestoredBounds(),
-                                   show_state));
+                                   show_state,
+                                   user_has_changed_window_or_position));
 
   commands->push_back(CreateSetWindowTypeCommand(
       browser->session_id(), WindowTypeForBrowserType(browser->type())));
 
   if (!browser->app_name().empty()) {
     commands->push_back(CreateSetWindowAppNameCommand(
         kCommandSetWindowAppName,
         browser->session_id().id(),
         browser->app_name()));
   }
@@ skipping 395 matching lines @@
       contents->GetController().GetDefaultSessionStorageNamespace();
   session_storage_namespace->SetShouldPersist(false);
   SessionTabHelper* session_tab_helper =
       SessionTabHelper::FromWebContents(contents);
   TabClosed(session_tab_helper->window_id(),
             session_tab_helper->session_id(),
             contents->GetClosedByUserGesture());
   RecordSessionUpdateHistogramData(content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                                    &last_updated_tab_closed_time_);
 }