1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
// 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.
#ifndef COMPONENTS_SESSIONS_CORE_BASE_SESSION_SERVICE_H_
#define COMPONENTS_SESSIONS_CORE_BASE_SESSION_SERVICE_H_
#include <memory>
#include "base/callback.h"
#include "base/files/file_path.h"
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "base/task/cancelable_task_tracker.h"
#include "components/sessions/core/sessions_export.h"
#include "url/gurl.h"
namespace sessions {
class BaseSessionServiceDelegate;
class SessionCommand;
class SessionBackend;
// BaseSessionService is the super class of both tab restore service and
// session service. It contains commonality needed by both, in particular
// it manages a set of SessionCommands that are periodically sent to a
// SessionBackend.
class SESSIONS_EXPORT BaseSessionService {
public:
// Identifies the type of session service this is. This is used by the
// backend to determine the name of the files.
enum SessionType {
SESSION_RESTORE,
TAB_RESTORE
};
typedef base::Callback<void(std::vector<std::unique_ptr<SessionCommand>>)>
GetCommandsCallback;
// Creates a new BaseSessionService. After creation you need to invoke
// Init. |delegate| will remain owned by the creator and it is guaranteed
// that its lifetime surpasses this class.
// |type| gives the type of session service, |path| the path to save files to.
BaseSessionService(SessionType type,
const base::FilePath& path,
BaseSessionServiceDelegate* delegate);
~BaseSessionService();
// Moves the current session to the last session.
void MoveCurrentSessionToLastSession();
// Deletes the last session.
void DeleteLastSession();
// Returns the set of commands which were scheduled to be written. Once
// committed to the backend, the commands are removed from here.
const std::vector<std::unique_ptr<SessionCommand>>& pending_commands() {
return pending_commands_;
}
// Whether the next save resets the file before writing to it.
void set_pending_reset(bool value) { pending_reset_ = value; }
bool pending_reset() const { return pending_reset_; }
// Returns the number of commands sent down since the last reset.
int commands_since_reset() const { return commands_since_reset_; }
// Schedules a command. This adds |command| to pending_commands_ and
// invokes StartSaveTimer to start a timer that invokes Save at a later
// time.
void ScheduleCommand(std::unique_ptr<SessionCommand> command);
// Appends a command as part of a general rebuild. This will neither count
// against a rebuild, nor will it trigger a save of commands.
void AppendRebuildCommand(std::unique_ptr<SessionCommand> command);
// Erase the |old_command| from the list of commands.
// The passed command will automatically be deleted.
void EraseCommand(SessionCommand* old_command);
// Swap a |new_command| into the list of queued commands at the location of
// the |old_command|. The |old_command| will be automatically deleted in the
// process.
void SwapCommand(SessionCommand* old_command,
std::unique_ptr<SessionCommand> new_command);
// Clears all commands from the list.
void ClearPendingCommands();
// Starts the timer that invokes Save (if timer isn't already running).
void StartSaveTimer();
// Passes all pending commands to the backend for saving.
void Save();
// Uses the backend to load the last session commands from disc. |callback|
// gets called once the data has arrived.
base::CancelableTaskTracker::TaskId ScheduleGetLastSessionCommands(
const GetCommandsCallback& callback,
base::CancelableTaskTracker* tracker);
private:
friend class BaseSessionServiceTestHelper;
// This posts the task to the SequencedWorkerPool, or run immediately
// if the SequencedWorkerPool has been shutdown.
void RunTaskOnBackendThread(const tracked_objects::Location& from_here,
const base::Closure& task);
// The backend object which reads and saves commands.
scoped_refptr<SessionBackend> backend_;
// Commands we need to send over to the backend.
std::vector<std::unique_ptr<SessionCommand>> pending_commands_;
// Whether the backend file should be recreated the next time we send
// over the commands.
bool pending_reset_;
// The number of commands sent to the backend before doing a reset.
int commands_since_reset_;
BaseSessionServiceDelegate* delegate_;
// A token to make sure that all tasks will be serialized.
base::SequencedWorkerPool::SequenceToken sequence_token_;
// Used to invoke Save.
base::WeakPtrFactory<BaseSessionService> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(BaseSessionService);
};
} // namespace sessions
#endif // COMPONENTS_SESSIONS_CORE_BASE_SESSION_SERVICE_H_
|
