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
|
// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_BOOKMARKS_CHROME_BOOKMARK_CLIENT_H_
#define CHROME_BROWSER_BOOKMARKS_CHROME_BOOKMARK_CLIENT_H_
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <vector>
#include "base/memory/raw_ptr.h"
#include "base/scoped_observation.h"
#include "base/task/deferred_sequenced_task_runner.h"
#include "components/bookmarks/browser/base_bookmark_model_observer.h"
#include "components/bookmarks/browser/bookmark_model.h"
#include "components/offline_pages/buildflags/buildflags.h"
#include "components/power_bookmarks/core/bookmark_client_base.h"
class BookmarkUndoService;
class GURL;
class Profile;
namespace bookmarks {
class BookmarkModel;
class BookmarkNode;
class ManagedBookmarkService;
} // namespace bookmarks
namespace sync_bookmarks {
class BookmarkSyncService;
} // namespace sync_bookmarks
#if BUILDFLAG(ENABLE_OFFLINE_PAGES)
namespace offline_pages {
class OfflinePageBookmarkObserver;
} // namespace offline_pages
#endif
namespace power_bookmarks {
class SuggestedSaveLocationProvider;
}
namespace signin {
class PersistentRepeatingTimer;
} // namespace signin
class ChromeBookmarkClient : public power_bookmarks::BookmarkClientBase {
public:
ChromeBookmarkClient(
Profile* profile,
bookmarks::ManagedBookmarkService* managed_bookmark_service,
sync_bookmarks::BookmarkSyncService*
local_or_syncable_bookmark_sync_service,
sync_bookmarks::BookmarkSyncService* account_bookmark_sync_service,
BookmarkUndoService* bookmark_undo_service);
ChromeBookmarkClient(const ChromeBookmarkClient&) = delete;
ChromeBookmarkClient& operator=(const ChromeBookmarkClient&) = delete;
~ChromeBookmarkClient() override;
// bookmarks::BookmarkClient:
void Init(bookmarks::BookmarkModel* model) override;
base::CancelableTaskTracker::TaskId GetFaviconImageForPageURL(
const GURL& page_url,
favicon_base::FaviconImageCallback callback,
base::CancelableTaskTracker* tracker) override;
bool SupportsTypedCountForUrls() override;
void GetTypedCountForUrls(UrlTypedCountMap* url_typed_count_map) override;
bookmarks::LoadManagedNodeCallback GetLoadManagedNodeCallback() override;
bool IsSyncFeatureEnabledIncludingBookmarks() override;
bool CanSetPermanentNodeTitle(
const bookmarks::BookmarkNode* permanent_node) override;
bool IsNodeManaged(const bookmarks::BookmarkNode* node) override;
std::string EncodeLocalOrSyncableBookmarkSyncMetadata() override;
std::string EncodeAccountBookmarkSyncMetadata() override;
void DecodeLocalOrSyncableBookmarkSyncMetadata(
const std::string& metadata_str,
const base::RepeatingClosure& schedule_save_closure) override;
DecodeAccountBookmarkSyncMetadataResult DecodeAccountBookmarkSyncMetadata(
const std::string& metadata_str,
const base::RepeatingClosure& schedule_save_closure) override;
void OnBookmarkNodeRemovedUndoable(
const bookmarks::BookmarkNode* parent,
size_t index,
std::unique_ptr<bookmarks::BookmarkNode> node) override;
void SchedulePersistentTimerForDailyMetrics(
base::RepeatingClosure metrics_callback) override;
private:
// Pointer to the associated Profile. Must outlive ChromeBookmarkClient.
const raw_ptr<Profile> profile_;
// Pointer to the ManagedBookmarkService responsible for bookmark policy. May
// be null during testing.
const raw_ptr<bookmarks::ManagedBookmarkService> managed_bookmark_service_;
// Pointers to the two BookmarkSyncService instances responsible for encoding
// and decoding sync metadata persisted together with the bookmarks model.
const raw_ptr<sync_bookmarks::BookmarkSyncService>
local_or_syncable_bookmark_sync_service_;
const raw_ptr<sync_bookmarks::BookmarkSyncService>
account_bookmark_sync_service_;
// Pointer to BookmarkUndoService, responsible for making operations undoable.
const raw_ptr<BookmarkUndoService> bookmark_undo_service_;
raw_ptr<bookmarks::BookmarkModel> model_ = nullptr;
std::unique_ptr<power_bookmarks::SuggestedSaveLocationProvider>
shopping_save_location_provider_;
std::unique_ptr<signin::PersistentRepeatingTimer> repeating_timer_;
#if BUILDFLAG(ENABLE_OFFLINE_PAGES)
// Owns the observer used by Offline Page listening to Bookmark Model events.
std::unique_ptr<offline_pages::OfflinePageBookmarkObserver>
offline_page_observer_;
// Observation of this by the bookmark model.
std::unique_ptr<base::ScopedObservation<bookmarks::BookmarkModel,
bookmarks::BaseBookmarkModelObserver>>
model_observation_{};
#endif
};
#endif // CHROME_BROWSER_BOOKMARKS_CHROME_BOOKMARK_CLIENT_H_
|
