[sessions] Properly namespace recently-componentized TabRestore code

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 <cstring>  // memcpy
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/stl_util.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/time/time.h"
 #include "components/sessions/base_session_service.h"
 #include "components/sessions/base_session_service_commands.h"
 #include "components/sessions/base_session_service_delegate.h"
 #include "components/sessions/core/session_constants.h"
 #include "components/sessions/session_command.h"
 
-using sessions::LiveTab;
+namespace sessions {
 
 namespace {
 
 // Only written if the tab is pinned.
 typedef bool PinnedStatePayload;
 
 typedef int32 RestoredEntryPayload;
 
 typedef std::map<SessionID::id_type, TabRestoreService::Entry*> IDToEntry;
 
@@ skipping 49 matching lines @@
 //   the selected index, then a kCommandPinnedState command if the tab was
 //   pinned and kCommandSetExtensionAppID if the tab has an app id and
 //   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 sessions::SessionCommand::id_type kCommandUpdateTabNavigation = 1;
-const sessions::SessionCommand::id_type kCommandRestoredEntry = 2;
-const sessions::SessionCommand::id_type kCommandWindow = 3;
-const sessions::SessionCommand::id_type kCommandSelectedNavigationInTab = 4;
-const sessions::SessionCommand::id_type kCommandPinnedState = 5;
-const sessions::SessionCommand::id_type kCommandSetExtensionAppID = 6;
-const sessions::SessionCommand::id_type kCommandSetWindowAppName = 7;
-const sessions::SessionCommand::id_type kCommandSetTabUserAgentOverride = 8;
+const SessionCommand::id_type kCommandUpdateTabNavigation = 1;
+const SessionCommand::id_type kCommandRestoredEntry = 2;
+const SessionCommand::id_type kCommandWindow = 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;
 
 // Number of entries (not commands) before we clobber the file and write
 // everything.
 const int kEntriesPerReset = 40;
 
 const size_t kMaxEntries = TabRestoreServiceHelper::kMaxEntries;
 
 }  // namespace
 
 // PersistentTabRestoreService::Delegate ---------------------------------------
 
 // This restore service will create and own a BaseSessionService and implement
-// the required sessions::BaseSessionServiceDelegate.
+// the required BaseSessionServiceDelegate.
 class PersistentTabRestoreService::Delegate
-    : public sessions::BaseSessionServiceDelegate,
+    : public BaseSessionServiceDelegate,
       public TabRestoreServiceHelper::Observer {
  public:
-  explicit Delegate(sessions::TabRestoreServiceClient* client);
+  explicit Delegate(TabRestoreServiceClient* client);
 
   ~Delegate() override;
 
-  // sessions::BaseSessionServiceDelegate:
+  // BaseSessionServiceDelegate:
   base::SequencedWorkerPool* GetBlockingPool() override;
   bool ShouldUseDelayedSave() override;
   void OnWillSaveCommands() override;
 
   // TabRestoreServiceHelper::Observer:
   void OnClearEntries() override;
   void OnRestoreEntryById(SessionID::id_type id,
                           Entries::const_iterator entry_iterator) override;
   void OnAddEntry() override;
 
   void set_tab_restore_service_helper(
       TabRestoreServiceHelper* tab_restore_service_helper) {
     tab_restore_service_helper_ = tab_restore_service_helper;
   }
 
   void LoadTabsFromLastSession();
 
   void DeleteLastSession();
 
   bool IsLoaded() const;
 
   // Creates and add entries to |entries| for each of the windows in |windows|.
-  static void CreateEntriesFromWindows(
-      std::vector<sessions::SessionWindow*>* windows,
-      std::vector<Entry*>* entries);
+  static void CreateEntriesFromWindows(std::vector<SessionWindow*>* windows,
+                                       std::vector<Entry*>* entries);
 
   void Shutdown();
 
   // 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 scoped_ptr<sessions::SessionCommand> CreateWindowCommand(
-      SessionID::id_type id,
-      int selected_tab_index,
-      int num_tabs,
-      base::Time timestamp);
+  static scoped_ptr<SessionCommand> CreateWindowCommand(SessionID::id_type id,
+                                                        int selected_tab_index,
+                                                        int num_tabs,
+                                                        base::Time timestamp);
 
   // Creates a tab close command.
-  static scoped_ptr<sessions::SessionCommand>
-  CreateSelectedNavigationInTabCommand(
+  static scoped_ptr<SessionCommand> CreateSelectedNavigationInTabCommand(
       SessionID::id_type tab_id,
       int32 index,
       base::Time timestamp);
 
   // Creates a restore command.
-  static scoped_ptr<sessions::SessionCommand> CreateRestoredEntryCommand(
-    SessionID::id_type entry_id);
+  static scoped_ptr<SessionCommand> CreateRestoredEntryCommand(
+      SessionID::id_type entry_id);
 
   // Returns the index to persist as the selected index. This is the same as
   // |tab.current_navigation_index| unless the entry at
   // |tab.current_navigation_index| shouldn't be persisted. Returns -1 if no
   // valid navigation to persist.
   int GetSelectedNavigationIndexToPersist(const Tab& tab);
 
   // Invoked when we've loaded the session commands that identify the previously
   // closed tabs. This creates entries, adds them to staging_entries_, and
   // invokes LoadState.
-  void OnGotLastSessionCommands(
-      ScopedVector<sessions::SessionCommand> commands);
+  void OnGotLastSessionCommands(ScopedVector<SessionCommand> commands);
 
   // Populates |loaded_entries| with Entries from |commands|.
-  void CreateEntriesFromCommands(
-      const std::vector<sessions::SessionCommand*>& commands,
-      std::vector<Entry*>* loaded_entries);
+  void CreateEntriesFromCommands(const std::vector<SessionCommand*>& commands,
+                                 std::vector<Entry*>* loaded_entries);
 
   // Validates all entries in |entries|, deleting any with no navigations. This
   // also deletes any entries beyond the max number of entries we can hold.
   static void ValidateAndDeleteEmptyEntries(std::vector<Entry*>* entries);
 
   // Callback from BaseSessionService when we've received the windows from the
   // previous session. This creates and add entries to |staging_entries_| and
   // invokes LoadStateChanged. |ignored_active_window| is ignored because we
   // don't need to restore activation.
-  void OnGotPreviousSession(ScopedVector<sessions::SessionWindow> windows,
+  void OnGotPreviousSession(ScopedVector<SessionWindow> windows,
                             SessionID::id_type ignored_active_window);
 
   // Converts a SessionWindow into a Window, returning true on success. We use 0
   // as the timestamp here since we do not know when the window/tab was closed.
-  static bool ConvertSessionWindowToWindow(
-      sessions::SessionWindow* session_window,
-      Window* window);
+  static bool ConvertSessionWindowToWindow(SessionWindow* session_window,
+                                           Window* window);
 
   // Invoked when previous tabs or session is loaded. If both have finished
   // loading the entries in |staging_entries_| are added to entries and
   // observers are notified.
   void LoadStateChanged();
 
   // If |id_to_entry| contains an entry for |id| the corresponding entry is
   // deleted and removed from both |id_to_entry| and |entries|. This is used
   // when creating entries from the backend file.
   void RemoveEntryByID(SessionID::id_type id,
                        IDToEntry* id_to_entry,
                        std::vector<TabRestoreService::Entry*>* entries);
 
  private:
   // The associated client.
-  sessions::TabRestoreServiceClient* client_;
+  TabRestoreServiceClient* client_;
 
-  scoped_ptr<sessions::BaseSessionService> base_session_service_;
+  scoped_ptr<BaseSessionService> base_session_service_;
 
   TabRestoreServiceHelper* tab_restore_service_helper_;
 
   // The number of entries to write.
   int entries_to_write_;
 
   // Number of entries we've written.
   int entries_written_;
 
   // Whether we've loaded the last session.
   int load_state_;
 
   // Results from previously closed tabs/sessions is first added here. When the
   // results from both us and the session restore service have finished loading
   // LoadStateChanged is invoked, which adds these entries to entries_.
   ScopedVector<Entry> staging_entries_;
 
   // Used when loading previous tabs/session and open tabs/session.
   base::CancelableTaskTracker cancelable_task_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(Delegate);
 };
 
-PersistentTabRestoreService::Delegate::Delegate(
-    sessions::TabRestoreServiceClient* client)
+PersistentTabRestoreService::Delegate::Delegate(TabRestoreServiceClient* client)
     : client_(client),
-      base_session_service_(new sessions::BaseSessionService(
-          sessions::BaseSessionService::TAB_RESTORE,
-          client_->GetPathToSaveTo(),
-          this)),
+      base_session_service_(
+          new BaseSessionService(BaseSessionService::TAB_RESTORE,
+                                 client_->GetPathToSaveTo(),
+                                 this)),
       tab_restore_service_helper_(NULL),
       entries_to_write_(0),
       entries_written_(0),
       load_state_(NOT_LOADED) {}
 
 PersistentTabRestoreService::Delegate::~Delegate() {}
 
 base::SequencedWorkerPool*
 PersistentTabRestoreService::Delegate::GetBlockingPool() {
   return client_->GetBlockingPool();
@@ skipping 105 matching lines @@
 void PersistentTabRestoreService::Delegate::DeleteLastSession() {
   base_session_service_->DeleteLastSession();
 }
 
 bool PersistentTabRestoreService::Delegate::IsLoaded() const {
   return !(load_state_ & (NOT_LOADED | LOADING));
 }
 
 // static
 void PersistentTabRestoreService::Delegate::CreateEntriesFromWindows(
-    std::vector<sessions::SessionWindow*>* windows,
+    std::vector<SessionWindow*>* windows,
     std::vector<Entry*>* entries) {
   for (size_t i = 0; i < windows->size(); ++i) {
     scoped_ptr<Window> window(new Window());
     if (ConvertSessionWindowToWindow((*windows)[i], window.get()))
       entries->push_back(window.release());
   }
 }
 
 void PersistentTabRestoreService::Delegate::Shutdown() {
   base_session_service_->Save();
@@ skipping 16 matching lines @@
     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).Pass());
 
   if (!window.app_name.empty()) {
     base_session_service_->ScheduleCommand(
-        sessions::CreateSetWindowAppNameCommand(kCommandSetWindowAppName,
-                                                window.id,
-                                                window.app_name).Pass());
+        CreateSetWindowAppNameCommand(kCommandSetWindowAppName, window.id,
+                                      window.app_name)
+            .Pass());
   }
 
   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);
   }
 }
 
 void PersistentTabRestoreService::Delegate::ScheduleCommandsForTab(
     const Tab& tab,
     int selected_index) {
-  const std::vector<sessions::SerializedNavigationEntry>& navigations =
-      tab.navigations;
+  const std::vector<SerializedNavigationEntry>& navigations = tab.navigations;
   int max_index = static_cast<int>(navigations.size());
 
   // Determine the first navigation we'll persist.
   int valid_count_before_selected = 0;
   int first_index_to_persist = selected_index;
   for (int i = selected_index - 1;
-       i >= 0 &&
-       valid_count_before_selected < sessions::gMaxPersistNavigationCount;
+       i >= 0 && valid_count_before_selected < gMaxPersistNavigationCount;
        --i) {
     if (client_->ShouldTrackURLForRestore(navigations[i].virtual_url())) {
       first_index_to_persist = i;
       valid_count_before_selected++;
     }
   }
 
   // Write the command that identifies the selected tab.
   base_session_service_->ScheduleCommand(
       CreateSelectedNavigationInTabCommand(tab.id,
                                            valid_count_before_selected,
                                            tab.timestamp).Pass());
 
   if (tab.pinned) {
     PinnedStatePayload payload = true;
-    scoped_ptr<sessions::SessionCommand> command(
-        new sessions::SessionCommand(kCommandPinnedState, sizeof(payload)));
+    scoped_ptr<SessionCommand> command(
+        new SessionCommand(kCommandPinnedState, sizeof(payload)));
     memcpy(command->contents(), &payload, sizeof(payload));
     base_session_service_->ScheduleCommand(command.Pass());
   }
 
   if (!tab.extension_app_id.empty()) {
     base_session_service_->ScheduleCommand(
-        sessions::CreateSetTabExtensionAppIDCommand(
-            kCommandSetExtensionAppID,
-            tab.id,
-            tab.extension_app_id).Pass());
+        CreateSetTabExtensionAppIDCommand(kCommandSetExtensionAppID, tab.id,
+                                          tab.extension_app_id)
+            .Pass());
   }
 
   if (!tab.user_agent_override.empty()) {
     base_session_service_->ScheduleCommand(
-        sessions::CreateSetTabUserAgentOverrideCommand(
-            kCommandSetTabUserAgentOverride,
-            tab.id,
-            tab.user_agent_override).Pass());
+        CreateSetTabUserAgentOverrideCommand(kCommandSetTabUserAgentOverride,
+                                             tab.id, tab.user_agent_override)
+            .Pass());
   }
 
   // Then write the navigations.
   for (int i = first_index_to_persist, wrote_count = 0;
-       wrote_count < 2 * sessions::gMaxPersistNavigationCount && i < max_index;
-       ++i) {
+       wrote_count < 2 * gMaxPersistNavigationCount && i < max_index; ++i) {
     if (client_->ShouldTrackURLForRestore(navigations[i].virtual_url())) {
       base_session_service_->ScheduleCommand(
           CreateUpdateTabNavigationCommand(kCommandUpdateTabNavigation,
                                            tab.id,
                                            navigations[i]));
     }
   }
 }
 
 // static
-scoped_ptr<sessions::SessionCommand>
+scoped_ptr<SessionCommand>
 PersistentTabRestoreService::Delegate::CreateWindowCommand(
     SessionID::id_type id,
     int selected_tab_index,
     int num_tabs,
     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();
 
-  scoped_ptr<sessions::SessionCommand> command(
-      new sessions::SessionCommand(kCommandWindow, sizeof(payload)));
+  scoped_ptr<SessionCommand> command(
+      new SessionCommand(kCommandWindow, sizeof(payload)));
   memcpy(command->contents(), &payload, sizeof(payload));
   return command;
 }
 
 // static
-scoped_ptr<sessions::SessionCommand>
+scoped_ptr<SessionCommand>
 PersistentTabRestoreService::Delegate::CreateSelectedNavigationInTabCommand(
     SessionID::id_type tab_id,
     int32 index,
     base::Time timestamp) {
   SelectedNavigationInTabPayload2 payload;
   payload.id = tab_id;
   payload.index = index;
   payload.timestamp = timestamp.ToInternalValue();
-  scoped_ptr<sessions::SessionCommand> command(
-      new sessions::SessionCommand(
-          kCommandSelectedNavigationInTab, sizeof(payload)));
+  scoped_ptr<SessionCommand> command(
+      new SessionCommand(kCommandSelectedNavigationInTab, sizeof(payload)));
   memcpy(command->contents(), &payload, sizeof(payload));
   return command;
 }
 
 // static
-scoped_ptr<sessions::SessionCommand>
+scoped_ptr<SessionCommand>
 PersistentTabRestoreService::Delegate::CreateRestoredEntryCommand(
     SessionID::id_type entry_id) {
   RestoredEntryPayload payload = entry_id;
-  scoped_ptr<sessions::SessionCommand> command(
-      new sessions::SessionCommand(kCommandRestoredEntry, sizeof(payload)));
+  scoped_ptr<SessionCommand> command(
+      new SessionCommand(kCommandRestoredEntry, sizeof(payload)));
   memcpy(command->contents(), &payload, sizeof(payload));
   return command;
 }
 
 int PersistentTabRestoreService::Delegate::GetSelectedNavigationIndexToPersist(
     const Tab& tab) {
-  const std::vector<sessions::SerializedNavigationEntry>& navigations =
-      tab.navigations;
+  const std::vector<SerializedNavigationEntry>& navigations = tab.navigations;
   int selected_index = tab.current_navigation_index;
   int max_index = static_cast<int>(navigations.size());
 
   // Find the first navigation to persist. We won't persist the selected
   // navigation if client_->ShouldTrackURLForRestore returns false.
   while (selected_index >= 0 &&
          !client_->ShouldTrackURLForRestore(
              navigations[selected_index].virtual_url())) {
     selected_index--;
   }
 
   if (selected_index != -1)
     return selected_index;
 
   // Couldn't find a navigation to persist going back, go forward.
   selected_index = tab.current_navigation_index + 1;
   while (selected_index < max_index &&
          !client_->ShouldTrackURLForRestore(
              navigations[selected_index].virtual_url())) {
     selected_index++;
   }
 
   return (selected_index == max_index) ? -1 : selected_index;
 }
 
 void PersistentTabRestoreService::Delegate::OnGotLastSessionCommands(
-    ScopedVector<sessions::SessionCommand> commands) {
+    ScopedVector<SessionCommand> commands) {
   std::vector<Entry*> entries;
   CreateEntriesFromCommands(commands.get(), &entries);
   // Closed tabs always go to the end.
   staging_entries_.insert(staging_entries_.end(), entries.begin(),
                           entries.end());
   load_state_ |= LOADED_LAST_TABS;
   LoadStateChanged();
 }
 
 void PersistentTabRestoreService::Delegate::CreateEntriesFromCommands(
-    const std::vector<sessions::SessionCommand*>& commands,
+    const std::vector<SessionCommand*>& commands,
     std::vector<Entry*>* loaded_entries) {
   if (tab_restore_service_helper_->entries().size() == kMaxEntries)
     return;
 
   // Iterate through the commands populating entries and id_to_entry.
   ScopedVector<Entry> entries;
   IDToEntry id_to_entry;
   // If non-null we're processing the navigations of this tab.
   Tab* current_tab = NULL;
   // If non-null we're processing the tabs of this window.
   Window* current_window = NULL;
   // If > 0, we've gotten a window command but not all the tabs yet.
   int pending_window_tabs = 0;
-  for (std::vector<sessions::SessionCommand*>::const_iterator i =
-           commands.begin(); i != commands.end(); ++i) {
-    const sessions::SessionCommand& command = *(*i);
+  for (std::vector<SessionCommand*>::const_iterator i = commands.begin();
+       i != commands.end(); ++i) {
+    const SessionCommand& command = *(*i);
     switch (command.id()) {
       case kCommandRestoredEntry: {
         if (pending_window_tabs > 0) {
           // Should never receive a restored command while waiting for all the
           // tabs in a window.
           return;
         }
 
         current_tab = NULL;
         current_window = NULL;
@@ skipping 182 matching lines @@
       invalid_entries.push_back(*i);
   }
   // NOTE: at this point the entries are ordered with newest at the front.
   entries->swap(valid_entries);
 
   // Delete the remaining entries.
   STLDeleteElements(&invalid_entries);
 }
 
 void PersistentTabRestoreService::Delegate::OnGotPreviousSession(
-    ScopedVector<sessions::SessionWindow> windows,
+    ScopedVector<SessionWindow> windows,
     SessionID::id_type ignored_active_window) {
   std::vector<Entry*> entries;
   CreateEntriesFromWindows(&windows.get(), &entries);
   // Previous session tabs go first.
   staging_entries_.insert(staging_entries_.begin(), entries.begin(),
                           entries.end());
   load_state_ |= LOADED_LAST_SESSION;
   LoadStateChanged();
 }
 
 bool PersistentTabRestoreService::Delegate::ConvertSessionWindowToWindow(
-    sessions::SessionWindow* session_window,
+    SessionWindow* session_window,
     Window* window) {
   for (size_t i = 0; i < session_window->tabs.size(); ++i) {
     if (!session_window->tabs[i]->navigations.empty()) {
       window->tabs.resize(window->tabs.size() + 1);
       Tab& tab = window->tabs.back();
       tab.pinned = session_window->tabs[i]->pinned;
       tab.navigations.swap(session_window->tabs[i]->navigations);
       tab.current_navigation_index =
           session_window->tabs[i]->current_navigation_index;
       tab.extension_app_id = session_window->tabs[i]->extension_app_id;
@@ skipping 90 matching lines @@
           return;
         }
       }
     }
   }
 }
 
 // PersistentTabRestoreService -------------------------------------------------
 
 PersistentTabRestoreService::PersistentTabRestoreService(
-    scoped_ptr<sessions::TabRestoreServiceClient> client,
+    scoped_ptr<TabRestoreServiceClient> client,
     TimeFactory* time_factory)
     : client_(client.Pass()),
       delegate_(new Delegate(client_.get())),
       helper_(this, delegate_.get(), client_.get(), time_factory) {
   delegate_->set_tab_restore_service_helper(&helper_);
 }
 
 PersistentTabRestoreService::~PersistentTabRestoreService() {}
 
 void PersistentTabRestoreService::AddObserver(
@@ skipping 64 matching lines @@
   delegate_->LoadTabsFromLastSession();
 }
 
 TabRestoreService::Entries* PersistentTabRestoreService::mutable_entries() {
   return &helper_.entries_;
 }
 
 void PersistentTabRestoreService::PruneEntries() {
   helper_.PruneEntries();
 }
+
+}  // namespace sessions