Refactoring of SessionService to get componentized.

chrome/browser/sessions/persistent_tab_restore_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/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 "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/base_session_service.h"
+#include "chrome/browser/sessions/base_session_service_commands.h"
 #include "chrome/browser/sessions/base_session_service_delegate_impl.h"
 #include "chrome/browser/sessions/session_command.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
 #include "content/public/browser/session_storage_namespace.h"
 
 namespace {
 
 // Only written if the tab is pinned.
@@ skipping 374 matching lines @@
   if (valid_tab_count == 0)
     return;  // No tabs to persist.
 
   ScheduleCommand(
       CreateWindowCommand(window.id,
                           std::min(real_selected_tab, valid_tab_count - 1),
                           valid_tab_count,
                           window.timestamp));
 
   if (!window.app_name.empty()) {
-    ScheduleCommand(
-        CreateSetWindowAppNameCommand(kCommandSetWindowAppName,
-                                      window.id,
-                                      window.app_name));
+    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);
   }
 }
 
 void PersistentTabRestoreService::Delegate::ScheduleCommandsForTab(
@@ skipping 22 matching lines @@
 
   if (tab.pinned) {
     PinnedStatePayload payload = true;
     SessionCommand* command =
         new SessionCommand(kCommandPinnedState, sizeof(payload));
     memcpy(command->contents(), &payload, sizeof(payload));
     ScheduleCommand(command);
   }
 
   if (!tab.extension_app_id.empty()) {
-    ScheduleCommand(
-        CreateSetTabExtensionAppIDCommand(kCommandSetExtensionAppID, tab.id,
-                                          tab.extension_app_id));
+    ScheduleCommand(CreateSetTabExtensionAppIDCommand(
+                          kCommandSetExtensionAppID,
+                          tab.id,
+                          tab.extension_app_id));
   }
 
   if (!tab.user_agent_override.empty()) {
-    ScheduleCommand(
-        CreateSetTabUserAgentOverrideCommand(kCommandSetTabUserAgentOverride,
-                                             tab.id, tab.user_agent_override));
+    ScheduleCommand(CreateSetTabUserAgentOverrideCommand(
+                          kCommandSetTabUserAgentOverride,
+                          tab.id,
+                          tab.user_agent_override));
   }
 
   // Then write the navigations.
   for (int i = first_index_to_persist, wrote_count = 0;
        i < max_index && wrote_count < 2 * max_persist_navigation_count; ++i) {
     if (ShouldTrackEntry(navigations[i].virtual_url())) {
-      ScheduleCommand(
-          CreateUpdateTabNavigationCommand(kCommandUpdateTabNavigation, tab.id,
-                                           navigations[i]));
+      ScheduleCommand(CreateUpdateTabNavigationCommand(
+                            kCommandUpdateTabNavigation,
+                            tab.id,
+                            navigations[i]));
     }
   }
 }
 
 // static
 SessionCommand* PersistentTabRestoreService::Delegate::CreateWindowCommand(
     SessionID::id_type id,
     int selected_tab_index,
     int num_tabs,
     base::Time timestamp) {
@@ skipping 189 matching lines @@
         break;
       }
 
       case kCommandUpdateTabNavigation: {
         if (!current_tab) {
           // Should be in a tab when we get this.
           return;
         }
         current_tab->navigations.resize(current_tab->navigations.size() + 1);
         SessionID::id_type tab_id;
-        if (!RestoreUpdateTabNavigationCommand(
-            command, &current_tab->navigations.back(), &tab_id)) {
+        if (!RestoreUpdateTabNavigationCommand(command,
+                                               &current_tab->navigations.back(),
+                                               &tab_id)) {
           return;
         }
         break;
       }
 
       case kCommandPinnedState: {
         if (!current_tab) {
           // Should be in a tab when we get this.
           return;
         }
@@ skipping 19 matching lines @@
         break;
       }
 
       case kCommandSetExtensionAppID: {
         if (!current_tab) {
           // Should be in a tab when we get this.
           return;
         }
         SessionID::id_type tab_id;
         std::string extension_app_id;
-        if (!RestoreSetTabExtensionAppIDCommand(command, &tab_id,
+        if (!RestoreSetTabExtensionAppIDCommand(command,
+                                                &tab_id,
                                                 &extension_app_id)) {
           return;
         }
         current_tab->extension_app_id.swap(extension_app_id);
         break;
       }
 
       case kCommandSetTabUserAgentOverride: {
         if (!current_tab) {
           // Should be in a tab when we get this.
           return;
         }
         SessionID::id_type tab_id;
         std::string user_agent_override;
-        if (!RestoreSetTabUserAgentOverrideCommand(command, &tab_id,
+        if (!RestoreSetTabUserAgentOverrideCommand(command,
+                                                   &tab_id,
                                                    &user_agent_override)) {
           return;
         }
         current_tab->user_agent_override.swap(user_agent_override);
         break;
       }
 
       default:
         // Unknown type, usually indicates corruption of file. Ignore it.
         return;
@@ skipping 236 matching lines @@
 }
 
 void PersistentTabRestoreService::PruneEntries() {
   helper_.PruneEntries();
 }
 
 KeyedService* TabRestoreServiceFactory::BuildServiceInstanceFor(
     content::BrowserContext* profile) const {
   return new PersistentTabRestoreService(static_cast<Profile*>(profile), NULL);
 }