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
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ui/tabs/pinned_tab_codec.h"
#include <stddef.h>
#include <utility>
#include "base/values.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/browser_list.h"
#include "chrome/browser/ui/tabs/tab_strip_model.h"
#include "chrome/common/pref_names.h"
#include "components/pref_registry/pref_registry_syncable.h"
#include "components/prefs/pref_service.h"
#include "components/prefs/scoped_user_pref_update.h"
#include "content/public/browser/navigation_entry.h"
#include "content/public/browser/web_contents.h"
using content::NavigationEntry;
namespace {
// Key used in dictionaries for the url.
const char kURL[] = "url";
// Returns a Value::Dict representing the supplied StartupTab.
base::Value::Dict EncodeTab(const GURL& url) {
base::Value::Dict dict;
dict.Set(kURL, url.spec());
return dict;
}
// Encodes all the pinned tabs from |browser| into |serialized_tabs|.
void EncodePinnedTabs(Browser* browser, base::Value::List& serialized_tabs) {
TabStripModel* tab_model = browser->tab_strip_model();
for (int i = 0; i < tab_model->count() && tab_model->IsTabPinned(i); ++i) {
content::WebContents* web_contents = tab_model->GetWebContentsAt(i);
NavigationEntry* entry =
web_contents->GetController().GetLastCommittedEntry();
if (entry) {
serialized_tabs.Append(EncodeTab(entry->GetURL()));
}
}
}
// Decodes the previously written values in |value| to |tab|, returning true
// on success.
std::optional<StartupTab> DecodeTab(const base::Value::Dict& value) {
const std::string* const url_string = value.FindString(kURL);
return url_string ? std::make_optional(StartupTab(GURL(*url_string),
StartupTab::Type::kPinned))
: std::nullopt;
}
} // namespace
// static
void PinnedTabCodec::RegisterProfilePrefs(
user_prefs::PrefRegistrySyncable* registry) {
registry->RegisterListPref(prefs::kPinnedTabs);
}
// static
void PinnedTabCodec::WritePinnedTabs(Profile* profile) {
PrefService* prefs = profile->GetPrefs();
if (!prefs) {
return;
}
base::Value::List values;
for (Browser* browser : *BrowserList::GetInstance()) {
if (browser->is_type_normal() && browser->profile() == profile) {
EncodePinnedTabs(browser, values);
}
}
prefs->SetList(prefs::kPinnedTabs, std::move(values));
}
// static
void PinnedTabCodec::WritePinnedTabs(Profile* profile,
const StartupTabs& tabs) {
PrefService* prefs = profile->GetPrefs();
if (!prefs) {
return;
}
ScopedListPrefUpdate update(prefs, prefs::kPinnedTabs);
base::Value::List& values = update.Get();
values.clear();
for (const auto& tab : tabs) {
values.Append(EncodeTab(tab.url));
}
}
// static
StartupTabs PinnedTabCodec::ReadPinnedTabs(Profile* profile) {
PrefService* prefs = profile->GetPrefs();
if (!prefs) {
return {};
}
StartupTabs results;
for (const auto& serialized_tab : prefs->GetList(prefs::kPinnedTabs)) {
if (!serialized_tab.is_dict()) {
continue;
}
std::optional<StartupTab> tab = DecodeTab(serialized_tab.GetDict());
if (tab.has_value()) {
results.push_back(tab.value());
}
}
return results;
}
|
