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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
// Copyright (c) 2011 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 CHROME_BROWSER_BOOKMARKS_BOOKMARK_STORAGE_H_
#define CHROME_BROWSER_BOOKMARKS_BOOKMARK_STORAGE_H_
#pragma once
#include "base/file_path.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "chrome/browser/bookmarks/bookmark_index.h"
#include "chrome/common/important_file_writer.h"
#include "content/common/notification_observer.h"
#include "content/common/notification_registrar.h"
class BookmarkModel;
class BookmarkNode;
class Profile;
// BookmarkLoadDetails is used by BookmarkStorage when loading bookmarks.
// BookmarkModel creates a BookmarkLoadDetails and passes it (including
// ownership) to BookmarkStorage. BoomarkStorage loads the bookmarks (and index)
// in the background thread, then calls back to the BookmarkModel (on the main
// thread) when loading is done, passing ownership back to the BookmarkModel.
// While loading BookmarkModel does not maintain references to the contents
// of the BookmarkLoadDetails, this ensures we don't have any threading
// problems.
class BookmarkLoadDetails {
public:
BookmarkLoadDetails(BookmarkNode* bb_node,
BookmarkNode* other_folder_node,
BookmarkIndex* index,
int64 max_id);
~BookmarkLoadDetails();
BookmarkNode* bb_node() { return bb_node_.get(); }
BookmarkNode* release_bb_node() { return bb_node_.release(); }
BookmarkNode* other_folder_node() { return other_folder_node_.get(); }
BookmarkNode* release_other_folder_node() {
return other_folder_node_.release();
}
BookmarkIndex* index() { return index_.get(); }
BookmarkIndex* release_index() { return index_.release(); }
// Max id of the nodes.
void set_max_id(int64 max_id) { max_id_ = max_id; }
int64 max_id() const { return max_id_; }
// Computed checksum.
void set_computed_checksum(const std::string& value) {
computed_checksum_ = value;
}
const std::string& computed_checksum() const { return computed_checksum_; }
// Stored checksum.
void set_stored_checksum(const std::string& value) {
stored_checksum_ = value;
}
const std::string& stored_checksum() const { return stored_checksum_; }
// Whether ids were reassigned.
void set_ids_reassigned(bool value) { ids_reassigned_ = value; }
bool ids_reassigned() const { return ids_reassigned_; }
private:
scoped_ptr<BookmarkNode> bb_node_;
scoped_ptr<BookmarkNode> other_folder_node_;
scoped_ptr<BookmarkIndex> index_;
int64 max_id_;
std::string computed_checksum_;
std::string stored_checksum_;
bool ids_reassigned_;
DISALLOW_COPY_AND_ASSIGN(BookmarkLoadDetails);
};
// BookmarkStorage handles reading/write the bookmark bar model. The
// BookmarkModel uses the BookmarkStorage to load bookmarks from disk, as well
// as notifying the BookmarkStorage every time the model changes.
//
// Internally BookmarkStorage uses BookmarkCodec to do the actual read/write.
class BookmarkStorage : public NotificationObserver,
public ImportantFileWriter::DataSerializer,
public base::RefCountedThreadSafe<BookmarkStorage> {
public:
// Creates a BookmarkStorage for the specified model
BookmarkStorage(Profile* profile, BookmarkModel* model);
// Loads the bookmarks into the model, notifying the model when done. This
// takes ownership of |details|. See BookmarkLoadDetails for details.
void LoadBookmarks(BookmarkLoadDetails* details);
// Schedules saving the bookmark bar model to disk.
void ScheduleSave();
// Notification the bookmark bar model is going to be deleted. If there is
// a pending save, it is saved immediately.
void BookmarkModelDeleted();
// ImportantFileWriter::DataSerializer
virtual bool SerializeData(std::string* output);
private:
friend class base::RefCountedThreadSafe<BookmarkStorage>;
~BookmarkStorage();
class LoadTask;
// Callback from backend with the results of the bookmark file.
// This may be called multiple times, with different paths. This happens when
// we migrate bookmark data from database.
void OnLoadFinished(bool file_exists,
const FilePath& path);
// Loads bookmark data from |file| and notifies the model when finished.
void DoLoadBookmarks(const FilePath& file);
// Load bookmarks data from the file written by history (StarredURLDatabase).
void MigrateFromHistory();
// Called when history has written the file with bookmarks data. Loads data
// from that file.
void OnHistoryFinishedWriting();
// Called after we loaded file generated by history. Saves the data, deletes
// the temporary file, and notifies the model.
void FinishHistoryMigration();
// NotificationObserver
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
// Serializes the data and schedules save using ImportantFileWriter.
// Returns true on successful serialization.
bool SaveNow();
// Keep the pointer to profile, we may need it for migration from history.
Profile* profile_;
// The model. The model is NULL once BookmarkModelDeleted has been invoked.
BookmarkModel* model_;
// Helper to write bookmark data safely.
ImportantFileWriter writer_;
// Helper to ensure that we unregister from notifications on destruction.
NotificationRegistrar notification_registrar_;
// Path to temporary file created during migrating bookmarks from history.
const FilePath tmp_history_path_;
// See class description of BookmarkLoadDetails for details on this.
scoped_ptr<BookmarkLoadDetails> details_;
DISALLOW_COPY_AND_ASSIGN(BookmarkStorage);
};
#endif // CHROME_BROWSER_BOOKMARKS_BOOKMARK_STORAGE_H_
|
