chrome/browser/sessions/base_session_service.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_SESSIONS_BASE_SESSION_SERVICE_H_
   6 #define CHROME_BROWSER_SESSIONS_BASE_SESSION_SERVICE_H_
   7
   8 #include "base/basictypes.h"
   9 #include "base/callback.h"
  10 #include "base/files/file_path.h"
  11 #include "base/gtest_prod_util.h"
  12 #include "base/location.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/scoped_vector.h"
  15 #include "base/memory/weak_ptr.h"
  16 #include "chrome/browser/common/cancelable_request.h"
  17 #include "chrome/browser/sessions/session_id.h"
  18 #include "chrome/common/cancelable_task_tracker.h"
  19 #include "googleurl/src/gurl.h"
  20
  21 class Profile;
  22 class SessionBackend;
  23 class SessionCommand;
  24 class TabNavigation;
  25
  26 // BaseSessionService is the super class of both tab restore service and
  27 // session service. It contains commonality needed by both, in particular
  28 // it manages a set of SessionCommands that are periodically sent to a
  29 // SessionBackend.
  30 class BaseSessionService : public CancelableRequestProvider {
  31  public:
  32   // Identifies the type of session service this is. This is used by the
  33   // backend to determine the name of the files.
  34   enum SessionType {
  35     SESSION_RESTORE,
  36     TAB_RESTORE
  37   };
  38
  39   // Creates a new BaseSessionService. After creation you need to invoke
  40   // Init.
  41   // |type| gives the type of session service, |profile| the profile and
  42   // |path| the path to save files to. If |profile| is non-NULL, |path| is
  43   // ignored and instead the path comes from the profile.
  44   BaseSessionService(SessionType type,
  45                      Profile* profile,
  46                      const base::FilePath& path);
  47
  48   Profile* profile() const { return profile_; }
  49
  50   // Deletes the last session.
  51   void DeleteLastSession();
  52
  53   typedef base::Callback<void(ScopedVector<SessionCommand>)>
  54       InternalGetCommandsCallback;
  55
  56  protected:
  57   virtual ~BaseSessionService();
  58
  59   // Returns the backend.
  60   SessionBackend* backend() const { return backend_; }
  61
  62   // Returns the set of commands that needed to be scheduled. The commands
  63   // in the vector are owned by BaseSessionService, until they are scheduled
  64   // on the backend at which point the backend owns the commands.
  65   std::vector<SessionCommand*>&  pending_commands() {
  66     return pending_commands_;
  67   }
  68
  69   // Whether the next save resets the file before writing to it.
  70   void set_pending_reset(bool value) { pending_reset_ = value; }
  71   bool pending_reset() const { return pending_reset_; }
  72
  73   // Returns the number of commands sent down since the last reset.
  74   int commands_since_reset() const { return commands_since_reset_; }
  75
  76   // Schedules a command. This adds |command| to pending_commands_ and
  77   // invokes StartSaveTimer to start a timer that invokes Save at a later
  78   // time.
  79   virtual void ScheduleCommand(SessionCommand* command);
  80
  81   // Starts the timer that invokes Save (if timer isn't already running).
  82   void StartSaveTimer();
  83
  84   // Saves pending commands to the backend. This is invoked from the timer
  85   // scheduled by StartSaveTimer.
  86   virtual void Save();
  87
  88   // Creates a SessionCommand that represents a navigation.
  89   SessionCommand* CreateUpdateTabNavigationCommand(
  90       SessionID::id_type command_id,
  91       SessionID::id_type tab_id,
  92       const TabNavigation& navigation);
  93
  94   // Creates a SessionCommand that represents marking a tab as an application.
  95   SessionCommand* CreateSetTabExtensionAppIDCommand(
  96       SessionID::id_type command_id,
  97       SessionID::id_type tab_id,
  98       const std::string& extension_id);
  99
 100   // Creates a SessionCommand that containing user agent override used by a
 101   // tab's navigations.
 102   SessionCommand* CreateSetTabUserAgentOverrideCommand(
 103       SessionID::id_type command_id,
 104       SessionID::id_type tab_id,
 105       const std::string& user_agent_override);
 106
 107   // Creates a SessionCommand stores a browser window's app name.
 108   SessionCommand* CreateSetWindowAppNameCommand(
 109       SessionID::id_type command_id,
 110       SessionID::id_type window_id,
 111       const std::string& app_name);
 112
 113   // Converts a SessionCommand previously created by
 114   // CreateUpdateTabNavigationCommand into a TabNavigation. Returns true
 115   // on success. If successful |tab_id| is set to the id of the restored tab.
 116   bool RestoreUpdateTabNavigationCommand(const SessionCommand& command,
 117                                          TabNavigation* navigation,
 118                                          SessionID::id_type* tab_id);
 119
 120   // Extracts a SessionCommand as previously created by
 121   // CreateSetTabExtensionAppIDCommand into the tab id and application
 122   // extension id.
 123   bool RestoreSetTabExtensionAppIDCommand(
 124       const SessionCommand& command,
 125       SessionID::id_type* tab_id,
 126       std::string* extension_app_id);
 127
 128   // Extracts a SessionCommand as previously created by
 129   // CreateSetTabUserAgentOverrideCommand into the tab id and user agent.
 130   bool RestoreSetTabUserAgentOverrideCommand(
 131       const SessionCommand& command,
 132       SessionID::id_type* tab_id,
 133       std::string* user_agent_override);
 134
 135   // Extracts a SessionCommand as previously created by
 136   // CreateSetWindowAppNameCommand into the window id and application name.
 137   bool RestoreSetWindowAppNameCommand(
 138       const SessionCommand& command,
 139       SessionID::id_type* window_id,
 140       std::string* app_name);
 141
 142   // Returns true if the entry at specified |url| should be written to disk.
 143   bool ShouldTrackEntry(const GURL& url);
 144
 145   // Invokes SessionBackend::ReadLastSessionCommands with callback on the
 146   // backend thread.
 147   // If testing, SessionBackend::ReadLastSessionCommands is invoked directly.
 148   CancelableTaskTracker::TaskId ScheduleGetLastSessionCommands(
 149       const InternalGetCommandsCallback& callback,
 150       CancelableTaskTracker* tracker);
 151
 152   // In production, this posts the task to the FILE thread.  For
 153   // tests, it immediately runs the specified task on the current
 154   // thread.
 155   bool RunTaskOnBackendThread(const tracked_objects::Location& from_here,
 156                               const base::Closure& task);
 157
 158   // Returns true if we appear to be running in production, false if we appear
 159   // to be running as part of a unit test or if the FILE thread has gone away.
 160   bool RunningInProduction() const;
 161
 162   // Max number of navigation entries in each direction we'll persist.
 163   static const int max_persist_navigation_count;
 164
 165  private:
 166   friend class BetterSessionRestoreCrashTest;
 167
 168   // The profile. This may be null during testing.
 169   Profile* profile_;
 170
 171   // The backend.
 172   scoped_refptr<SessionBackend> backend_;
 173
 174   // Used to invoke Save.
 175   base::WeakPtrFactory<BaseSessionService> weak_factory_;
 176
 177   // Commands we need to send over to the backend.
 178   std::vector<SessionCommand*>  pending_commands_;
 179
 180   // Whether the backend file should be recreated the next time we send
 181   // over the commands.
 182   bool pending_reset_;
 183
 184   // The number of commands sent to the backend before doing a reset.
 185   int commands_since_reset_;
 186
 187   DISALLOW_COPY_AND_ASSIGN(BaseSessionService);
 188 };
 189
 190 #endif  // CHROME_BROWSER_SESSIONS_BASE_SESSION_SERVICE_H_