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
|
// 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_
#include "base/files/important_file_writer.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "chrome/browser/bookmarks/bookmark_index.h"
class BookmarkModel;
class BookmarkPermanentNode;
namespace content {
class BrowserContext;
}
// BookmarkLoadDetails is used by BookmarkStorage when loading bookmarks.
// BookmarkModel creates a BookmarkLoadDetails and passes it (including
// ownership) to BookmarkStorage. BookmarkStorage 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(BookmarkPermanentNode* bb_node,
BookmarkPermanentNode* other_folder_node,
BookmarkPermanentNode* mobile_folder_node,
BookmarkIndex* index,
int64 max_id);
~BookmarkLoadDetails();
BookmarkPermanentNode* bb_node() { return bb_node_.get(); }
BookmarkPermanentNode* release_bb_node() { return bb_node_.release(); }
BookmarkPermanentNode* mobile_folder_node() {
return mobile_folder_node_.get();
}
BookmarkPermanentNode* release_mobile_folder_node() {
return mobile_folder_node_.release();
}
BookmarkPermanentNode* other_folder_node() {
return other_folder_node_.get();
}
BookmarkPermanentNode* release_other_folder_node() {
return other_folder_node_.release();
}
BookmarkIndex* index() { return index_.get(); }
BookmarkIndex* release_index() { return index_.release(); }
const std::string& model_meta_info() { return model_meta_info_; }
void set_model_meta_info(const std::string& meta_info) {
model_meta_info_ = meta_info;
}
// 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. IDs are reassigned during decoding if the
// checksum of the file doesn't match, some IDs are missing or not
// unique. Basically, if the user modified the bookmarks directly we'll
// reassign the ids to ensure they are unique.
void set_ids_reassigned(bool value) { ids_reassigned_ = value; }
bool ids_reassigned() const { return ids_reassigned_; }
private:
scoped_ptr<BookmarkPermanentNode> bb_node_;
scoped_ptr<BookmarkPermanentNode> other_folder_node_;
scoped_ptr<BookmarkPermanentNode> mobile_folder_node_;
scoped_ptr<BookmarkIndex> index_;
std::string model_meta_info_;
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 base::ImportantFileWriter::DataSerializer,
public base::RefCountedThreadSafe<BookmarkStorage> {
public:
// Creates a BookmarkStorage for the specified model
BookmarkStorage(content::BrowserContext* context, 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();
// Callback from backend after loading the bookmark file.
void OnLoadFinished();
// ImportantFileWriter::DataSerializer implementation.
virtual bool SerializeData(std::string* output) OVERRIDE;
private:
friend class base::RefCountedThreadSafe<BookmarkStorage>;
virtual ~BookmarkStorage();
// Serializes the data and schedules save using ImportantFileWriter.
// Returns true on successful serialization.
bool SaveNow();
// The model. The model is NULL once BookmarkModelDeleted has been invoked.
BookmarkModel* model_;
// Helper to write bookmark data safely.
base::ImportantFileWriter writer_;
// 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_
|
