Ensure History > Recent Tabs restore preserves window disposition.

components/sessions/core/persistent_tab_restore_service.cc

 // Copyright 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 "components/sessions/core/persistent_tab_restore_service.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <utility>
@@ skipping 27 matching lines @@
 // Payload used for the start of a tab close. This is the old struct that is
 // used for backwards compat when it comes to reading the session files.
 struct SelectedNavigationInTabPayload {
   SessionID::id_type id;
   int32_t index;
 };
 
 // Payload used for the start of a window close. This is the old struct that is
 // used for backwards compat when it comes to reading the session files. This
 // struct must be POD, because we memset the contents.
-struct WindowPayload {
+struct WindowPayloadObsolete {
   SessionID::id_type window_id;
   int32_t selected_tab_index;
   int32_t num_tabs;
 };
 
-// Payload used for the start of a window close.  This struct must be POD,
-// because we memset the contents.
-struct WindowPayload2 : WindowPayload {
+// Payload used for the start of a window close. This struct must be POD,
+// because we memset the contents. This is an older version of the struct that
+// is used for backwards compat when it comes to reading the session files.
+struct WindowPayloadObsolete2 : WindowPayloadObsolete {
   int64_t timestamp;
 };
 
 // Payload used for the start of a tab close.
 struct SelectedNavigationInTabPayload2 : SelectedNavigationInTabPayload {
   int64_t timestamp;
 };
 
 // Used to indicate what has loaded.
 enum LoadState {
@@ skipping 22 matching lines @@
 //   the user agent override if it was using one.  This is
 //   followed by any number of kCommandUpdateTabNavigation commands (1 per
 //   navigation entry).
 // . When the user closes a window a kCommandSelectedNavigationInTab command
 //   is written out and followed by n tab closed sequences (as previoulsy
 //   described).
 // . When the user restores an entry a command of type kCommandRestoredEntry
 //   is written.
 const SessionCommand::id_type kCommandUpdateTabNavigation = 1;
 const SessionCommand::id_type kCommandRestoredEntry = 2;
-const SessionCommand::id_type kCommandWindow = 3;
+const SessionCommand::id_type kCommandWindowDeprecated = 3;
 const SessionCommand::id_type kCommandSelectedNavigationInTab = 4;
 const SessionCommand::id_type kCommandPinnedState = 5;
 const SessionCommand::id_type kCommandSetExtensionAppID = 6;
 const SessionCommand::id_type kCommandSetWindowAppName = 7;
 const SessionCommand::id_type kCommandSetTabUserAgentOverride = 8;
+const SessionCommand::id_type kCommandWindow = 9;
 
 // Number of entries (not commands) before we clobber the file and write
 // everything.
 const int kEntriesPerReset = 40;
 
 const size_t kMaxEntries = TabRestoreServiceHelper::kMaxEntries;
 
 void RemoveEntryByID(
     SessionID::id_type id,
     std::vector<std::unique_ptr<TabRestoreService::Entry>>* entries) {
@@ skipping 13 matching lines @@
         // Erase it if it's our target.
         if (tab.id == id) {
           window.tabs.erase(it);
           return;
         }
       }
     }
   }
 }
 
+// An enum that corresponds to ui::WindowShowStates. This needs to be kept in
+// sync with that enum. Moreover, the integer values corresponding to each show
+// state need to be stable in this enum (which is not necessarily true about the
+// ui::WindowShowStates enum).
+enum SerializedWindowShowState : int {
+  kSerializedShowStateInvalid = -1,
+  kSerializedShowStateDefault = 0,
+  kSerializedShowStateNormal = 1,
+  kSerializedShowStateMinimized = 2,
+  kSerializedShowStateMaximized = 3,
+  kSerializedShowStateInactive = 4,
+  kSerializedShowStateFullscreen = 5,
+};
+
+// Converts a window show state to an integer. This function needs to be kept
+// up to date with the SerializedWindowShowState enum.
+int SerializeWindowShowState(ui::WindowShowState show_state) {
+  switch (show_state) {
+    case ui::SHOW_STATE_DEFAULT:
+      return kSerializedShowStateDefault;
+    case ui::SHOW_STATE_NORMAL:
+      return kSerializedShowStateNormal;
+    case ui::SHOW_STATE_MINIMIZED:
+      return kSerializedShowStateMinimized;
+    case ui::SHOW_STATE_MAXIMIZED:
+      return kSerializedShowStateMaximized;
+    case ui::SHOW_STATE_INACTIVE:
+      return kSerializedShowStateInactive;
+    case ui::SHOW_STATE_FULLSCREEN:
+      return kSerializedShowStateFullscreen;
+    case ui::SHOW_STATE_END:
+      // This should never happen.
+      NOTREACHED();
+  }
+  return kSerializedShowStateInvalid;
+}
+
+// Converts an integer to a window show state. Returns true on success, false
+// otherwise. This function needs to be kept up to date with the
+// SerializedWindowShowState enum.
+bool DeserializeWindowShowState(int show_state_int,
+                                ui::WindowShowState* show_state) {
+  switch (static_cast<SerializedWindowShowState>(show_state_int)) {
+    case kSerializedShowStateDefault:
+      *show_state = ui::SHOW_STATE_DEFAULT;
+      return true;
+    case kSerializedShowStateNormal:
+      *show_state = ui::SHOW_STATE_NORMAL;
+      return true;
+    case kSerializedShowStateMinimized:
+      *show_state = ui::SHOW_STATE_MINIMIZED;
+      return true;
+    case kSerializedShowStateMaximized:
+      *show_state = ui::SHOW_STATE_MAXIMIZED;
+      return true;
+    case kSerializedShowStateInactive:
+      *show_state = ui::SHOW_STATE_INACTIVE;
+      return true;
+    case kSerializedShowStateFullscreen:
+      *show_state = ui::SHOW_STATE_FULLSCREEN;
+      return true;
+    case kSerializedShowStateInvalid:
+    default:
+      // Ignore unknown values. This could happen if the data is corrupt.
+      break;
+  }
+  return false;
+}
+
+// Superset of WindowPayloadObsolete/WindowPayloadObsolete2 and the other fields
+// that can appear in the Pickle version of a Window command. This is used as a
+// convenient destination for parsing the various fields in a WindowCommand.
+struct WindowCommandFields {
+  // Fields in WindowPayloadObsolete/WindowPayloadObsolete2/Pickle:
+  int window_id = 0;
+  int selected_tab_index = 0;
+  int num_tabs = 0;
+
+  // Fields in WindowPayloadObsolete2/Pickle:
+  int64_t timestamp = 0;
+
+  // Fields in Pickle:
+  // Completely zeroed position/dimensions indicates that defaults should be
+  // used.
+  int window_x = 0;
+  int window_y = 0;
+  int window_width = 0;
+  int window_height = 0;
+  int window_show_state = 0;
+  std::string workspace;
+};
+
+std::unique_ptr<sessions::TabRestoreService::Window>
+CreateWindowEntryFromCommand(const SessionCommand* command,
+                             SessionID::id_type* window_id,
+                             int32_t* num_tabs) {
+  WindowCommandFields fields;
+  ui::WindowShowState show_state = ui::SHOW_STATE_DEFAULT;
+
+  if (command->id() == kCommandWindow) {
+    std::unique_ptr<base::Pickle> pickle(command->PayloadAsPickle());
+    if (!pickle.get())
+      return nullptr;
+
+    base::PickleIterator it(*pickle);
+    WindowCommandFields parsed_fields;
+
+    // The first version of the pickle contains all of the following fields, so
+    // they should all successfully parse if the command is in fact a pickle.
+    if (!it.ReadInt(&parsed_fields.window_id) ||
+        !it.ReadInt(&parsed_fields.selected_tab_index) ||
+        !it.ReadInt(&parsed_fields.num_tabs) ||
+        !it.ReadInt64(&parsed_fields.timestamp) ||
+        !it.ReadInt(&parsed_fields.window_x) ||
+        !it.ReadInt(&parsed_fields.window_y) ||
+        !it.ReadInt(&parsed_fields.window_width) ||
+        !it.ReadInt(&parsed_fields.window_height) ||
+        !it.ReadInt(&parsed_fields.window_show_state) ||
+        !it.ReadString(&parsed_fields.workspace)) {
+      return nullptr;
+    }
+
+    // Validate the parameters. If the entire pickles parses but any of the
+    // validation fails assume corruption.
+    if (parsed_fields.window_width < 0 || parsed_fields.window_height < 0)
+      return nullptr;
+
+    // Deserialize the show state, validating it at the same time.
+    if (!DeserializeWindowShowState(parsed_fields.window_show_state,
+                                    &show_state)) {
+      return nullptr;
+    }
+
+    // New fields added to the pickle in later versions would be parsed and
+    // validated here.
+
+    // Copy the parsed data.
+    fields = parsed_fields;
+  } else if (command->id() == kCommandWindowDeprecated) {
+    // Old window commands can be in either of 2 formats. Try the newest first.
+    // These have distinct sizes so are easily distinguished.
+    bool parsed = false;
+
+    // Try to parse the command as a WindowPayloadObsolete2.
+    WindowPayloadObsolete2 payload2;
+    if (command->GetPayload(&payload2, sizeof(payload2))) {
+      fields.window_id = payload2.window_id;
+      fields.selected_tab_index = payload2.selected_tab_index;
+      fields.num_tabs = payload2.num_tabs;
+      fields.timestamp = payload2.timestamp;
+      parsed = true;
+    }
+
+    // Finally, try the oldest WindowPayloadObsolete type.
+    if (!parsed) {
+      WindowPayloadObsolete payload;
+      if (command->GetPayload(&payload, sizeof(payload))) {
+        fields.window_id = payload.window_id;
+        fields.selected_tab_index = payload.selected_tab_index;
+        fields.num_tabs = payload.num_tabs;
+        parsed = true;
+      }
+    }
+
+    // Fail if the old command wasn't able to be parsed in either of the
+    // deprecated formats.
+    if (!parsed)
+      return nullptr;
+  } else {
+    // This should never be called with anything other than a known window
+    // command ID.
+    NOTREACHED();
+  }
+
+  // Create the Window entry.
+  std::unique_ptr<sessions::TabRestoreService::Window> window =
+      base::MakeUnique<sessions::TabRestoreService::Window>();
+  window->selected_tab_index = fields.selected_tab_index;
+  window->timestamp = base::Time::FromInternalValue(fields.timestamp);
+  *window_id = static_cast<SessionID::id_type>(fields.window_id);
+  *num_tabs = fields.num_tabs;
+
+  // Set the bounds, show state and workspace if valid ones have been provided.
+  if (!(fields.window_x == 0 && fields.window_y == 0 &&
+        fields.window_width == 0 && fields.window_height == 0)) {
+    window->bounds.SetRect(fields.window_x, fields.window_y,
+                           fields.window_width, fields.window_height);
+    // |show_state| was converted from window->show_state earlier during
+    // validation.
+    window->show_state = show_state;
+    window->workspace = std::move(fields.workspace);
+  }
+
+  return window;
+}
+
 }  // namespace
 
 // PersistentTabRestoreService::Delegate ---------------------------------------
 
 // This restore service will create and own a BaseSessionService and implement
 // the required BaseSessionServiceDelegate.
 class PersistentTabRestoreService::Delegate
     : public BaseSessionServiceDelegate,
       public TabRestoreServiceHelper::Observer {
  public:
@@ skipping 31 matching lines @@
 
   // Schedules the commands for a window close.
   void ScheduleCommandsForWindow(const Window& window);
 
   // Schedules the commands for a tab close. |selected_index| gives the index of
   // the selected navigation.
   void ScheduleCommandsForTab(const Tab& tab, int selected_index);
 
   // Creates a window close command.
   static std::unique_ptr<SessionCommand> CreateWindowCommand(
-      SessionID::id_type id,
+      SessionID::id_type window_id,
       int selected_tab_index,
       int num_tabs,
+      const gfx::Rect& bounds,
+      ui::WindowShowState show_state,
+      const std::string& workspace,
       base::Time timestamp);
 
   // Creates a tab close command.
   static std::unique_ptr<SessionCommand> CreateSelectedNavigationInTabCommand(
       SessionID::id_type tab_id,
       int32_t index,
       base::Time timestamp);
 
   // Creates a restore command.
   static std::unique_ptr<SessionCommand> CreateRestoredEntryCommand(
@@ skipping 220 matching lines @@
       valid_tab_count++;
     } else if (static_cast<int>(i) < selected_tab) {
       real_selected_tab--;
     }
   }
   if (valid_tab_count == 0)
     return;  // No tabs to persist.
 
   base_session_service_->ScheduleCommand(CreateWindowCommand(
       window.id, std::min(real_selected_tab, valid_tab_count - 1),
-      valid_tab_count, window.timestamp));
+      valid_tab_count, window.bounds, window.show_state, window.workspace,
+      window.timestamp));
 
   if (!window.app_name.empty()) {
     base_session_service_->ScheduleCommand(CreateSetWindowAppNameCommand(
         kCommandSetWindowAppName, window.id, window.app_name));
   }
 
   for (size_t i = 0; i < window.tabs.size(); ++i) {
     int selected_index = GetSelectedNavigationIndexToPersist(*window.tabs[i]);
     if (selected_index != -1)
       ScheduleCommandsForTab(*window.tabs[i], selected_index);
@@ skipping 48 matching lines @@
           CreateUpdateTabNavigationCommand(kCommandUpdateTabNavigation,
                                            tab.id,
                                            navigations[i]));
     }
   }
 }
 
 // static
 std::unique_ptr<SessionCommand>
 PersistentTabRestoreService::Delegate::CreateWindowCommand(
-    SessionID::id_type id,
+    SessionID::id_type window_id,
     int selected_tab_index,
     int num_tabs,
+    const gfx::Rect& bounds,
+    ui::WindowShowState show_state,
+    const std::string& workspace,
     base::Time timestamp) {
-  WindowPayload2 payload;
-  // |timestamp| is aligned on a 16 byte boundary, leaving 4 bytes of
-  // uninitialized memory in the struct.
-  memset(&payload, 0, sizeof(payload));
-  payload.window_id = id;
-  payload.selected_tab_index = selected_tab_index;
-  payload.num_tabs = num_tabs;
-  payload.timestamp = timestamp.ToInternalValue();
+  static_assert(sizeof(SessionID::id_type) == sizeof(int),
+                "SessionID::id_type has changed size.");
+
+  // Use a pickle to handle marshaling as this command contains variable-length
+  // content.
+  base::Pickle pickle;
+  pickle.WriteInt(static_cast<int>(window_id));
+  pickle.WriteInt(selected_tab_index);
+  pickle.WriteInt(num_tabs);
+  pickle.WriteInt64(timestamp.ToInternalValue());
+  pickle.WriteInt(bounds.x());
+  pickle.WriteInt(bounds.y());
+  pickle.WriteInt(bounds.width());
+  pickle.WriteInt(bounds.height());
+  pickle.WriteInt(SerializeWindowShowState(show_state));
+
+  // Enforce a maximum length on workspace names. A common size is 32 bytes for
+  // GUIDs.
+  if (workspace.size() <= 128)
+    pickle.WriteString(workspace);
+  else
+    pickle.WriteString(std::string());
 
   std::unique_ptr<SessionCommand> command(
-      new SessionCommand(kCommandWindow, sizeof(payload)));
-  memcpy(command->contents(), &payload, sizeof(payload));
+      new SessionCommand(kCommandWindow, pickle));
   return command;
 }
 
 // static
 std::unique_ptr<SessionCommand>
 PersistentTabRestoreService::Delegate::CreateSelectedNavigationInTabCommand(
     SessionID::id_type tab_id,
     int32_t index,
     base::Time timestamp) {
   SelectedNavigationInTabPayload2 payload;
@@ skipping 84 matching lines @@
         current_tab = nullptr;
         current_window = nullptr;
 
         RestoredEntryPayload payload;
         if (!command.GetPayload(&payload, sizeof(payload)))
           return;
         RemoveEntryByID(payload, &entries);
         break;
       }
 
+      case kCommandWindowDeprecated:
       case kCommandWindow: {
-        WindowPayload2 payload;
-        if (pending_window_tabs > 0) {
-          // Should never receive a window command while waiting for all the
-          // tabs in a window.
+        // Should never receive a window command while waiting for all the
+        // tabs in a window.
+        if (pending_window_tabs > 0)
           return;
-        }
 
-        // Try the new payload first
-        if (!command.GetPayload(&payload, sizeof(payload))) {
-          // then the old payload
-          WindowPayload old_payload;
-          if (!command.GetPayload(&old_payload, sizeof(old_payload)))
-            return;
+        // Try to parse the command, and silently skip if it fails.
+        int32_t num_tabs = 0;
+        SessionID::id_type window_id = 0;
+        std::unique_ptr<Window> window =
+            CreateWindowEntryFromCommand(&command, &window_id, &num_tabs);
+        if (!window)
+          return;
 
-          // Copy the old payload data to the new payload.
-          payload.window_id = old_payload.window_id;
-          payload.selected_tab_index = old_payload.selected_tab_index;
-          payload.num_tabs = old_payload.num_tabs;
-          // Since we don't have a time use time 0 which is used to mark as an
-          // unknown timestamp.
-          payload.timestamp = 0;
-        }
+        // Should always have at least 1 tab. Likely indicates corruption.
+        pending_window_tabs = num_tabs;
+        if (pending_window_tabs <= 0)
+          return;
 
-        pending_window_tabs = payload.num_tabs;
-        if (pending_window_tabs <= 0) {
-          // Should always have at least 1 tab. Likely indicates corruption.
-          return;
-        }
-
-        RemoveEntryByID(payload.window_id, &entries);
-
-        entries.push_back(base::MakeUnique<Window>());
-        current_window = static_cast<Window*>(entries.back().get());
-        current_window->selected_tab_index = payload.selected_tab_index;
-        current_window->timestamp =
-            base::Time::FromInternalValue(payload.timestamp);
+        RemoveEntryByID(window_id, &entries);
+        current_window = window.get();
+        entries.push_back(std::move(window));
         break;
       }
 
       case kCommandSelectedNavigationInTab: {
         SelectedNavigationInTabPayload2 payload;
         if (!command.GetPayload(&payload, sizeof(payload))) {
           SelectedNavigationInTabPayload old_payload;
           if (!command.GetPayload(&old_payload, sizeof(old_payload)))
             return;
           payload.id = old_payload.id;
@@ skipping 99 matching lines @@
       }
 
       default:
         // Unknown type, usually indicates corruption of file. Ignore it.
         return;
     }
   }
 
   // If there was corruption some of the entries won't be valid.
   ValidateAndDeleteEmptyEntries(&entries);
-
   loaded_entries->swap(entries);
 }
 
 // static
 void PersistentTabRestoreService::Delegate::ValidateAndDeleteEmptyEntries(
     std::vector<std::unique_ptr<Entry>>* entries) {
   std::vector<std::unique_ptr<Entry>> valid_entries;
 
   // Iterate from the back so that we keep the most recently closed entries.
   for (auto i = entries->rbegin(); i != entries->rend(); ++i) {
@@ skipping 32 matching lines @@
       tab.timestamp = base::Time();
     }
   }
   if (window->tabs.empty())
     return false;
 
   window->selected_tab_index =
       std::min(session_window->selected_tab_index,
                static_cast<int>(window->tabs.size() - 1));
   window->timestamp = base::Time();
+  window->bounds = session_window->bounds;
+  window->show_state = session_window->show_state;
+  window->workspace = session_window->workspace;
   return true;
 }
 
 void PersistentTabRestoreService::Delegate::LoadStateChanged() {
   if ((load_state_ & (LOADED_LAST_TABS | LOADED_LAST_SESSION)) !=
       (LOADED_LAST_TABS | LOADED_LAST_SESSION)) {
     // Still waiting on previous session or previous tabs.
     return;
   }
 
@@ skipping 118 matching lines @@
 
 TabRestoreService::Entries* PersistentTabRestoreService::mutable_entries() {
   return &helper_.entries_;
 }
 
 void PersistentTabRestoreService::PruneEntries() {
   helper_.PruneEntries();
 }
 
 }  // namespace sessions