1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "chrome/browser/sync/glue/synced_device_tracker.h"
6
7 #include "base/strings/stringprintf.h"
8 #include "base/strings/utf_string_conversions.h"
9 #include "chrome/browser/sync/glue/device_info.h"
10 #include "sync/internal_api/public/base/model_type.h"
11 #include "sync/internal_api/public/read_node.h"
12 #include "sync/internal_api/public/read_transaction.h"
13 #include "sync/internal_api/public/user_share.h"
14 #include "sync/internal_api/public/write_node.h"
15 #include "sync/internal_api/public/write_transaction.h"
16
17 namespace browser_sync {
18
19 namespace {
20
21 // Return the DeviceInfo UNIQUE_CLIENT_TAG value for the given sync cache_guid.
DeviceInfoLookupString(const std::string & cache_guid)22 std::string DeviceInfoLookupString(const std::string& cache_guid) {
23 return base::StringPrintf("DeviceInfo_%s", cache_guid.c_str());
24 }
25
26 } // namespace
27
SyncedDeviceTracker(syncer::UserShare * user_share,const std::string & cache_guid)28 SyncedDeviceTracker::SyncedDeviceTracker(syncer::UserShare* user_share,
29 const std::string& cache_guid)
30 : ChangeProcessor(NULL),
31 user_share_(user_share),
32 cache_guid_(cache_guid),
33 local_device_info_tag_(DeviceInfoLookupString(cache_guid)),
34 weak_factory_(this) {
35 observers_ = new ObserverListThreadSafe<Observer>;
36 }
37
~SyncedDeviceTracker()38 SyncedDeviceTracker::~SyncedDeviceTracker() {
39 }
40
StartImpl(Profile * profile)41 void SyncedDeviceTracker::StartImpl(Profile* profile) { }
42
ApplyChangesFromSyncModel(const syncer::BaseTransaction * trans,int64 model_version,const syncer::ImmutableChangeRecordList & changes)43 void SyncedDeviceTracker::ApplyChangesFromSyncModel(
44 const syncer::BaseTransaction* trans,
45 int64 model_version,
46 const syncer::ImmutableChangeRecordList& changes) {
47 // If desired, we could maintain a cache of device info. This method will be
48 // called with a transaction every time the device info is modified, so this
49 // would be the right place to update the cache.
50 }
51
CommitChangesFromSyncModel()52 void SyncedDeviceTracker::CommitChangesFromSyncModel() {
53 observers_->Notify(&Observer::OnDeviceInfoChange);
54 }
55
ReadLocalDeviceInfo() const56 scoped_ptr<DeviceInfo> SyncedDeviceTracker::ReadLocalDeviceInfo() const {
57 syncer::ReadTransaction trans(FROM_HERE, user_share_);
58 return ReadLocalDeviceInfo(trans);
59 }
60
ReadLocalDeviceInfo(const syncer::BaseTransaction & trans) const61 scoped_ptr<DeviceInfo> SyncedDeviceTracker::ReadLocalDeviceInfo(
62 const syncer::BaseTransaction& trans) const {
63 syncer::ReadNode node(&trans);
64 if (node.InitByClientTagLookup(syncer::DEVICE_INFO, local_device_info_tag_) !=
65 syncer::BaseNode::INIT_OK) {
66 return scoped_ptr<DeviceInfo>();
67 }
68
69 const sync_pb::DeviceInfoSpecifics& specifics = node.GetDeviceInfoSpecifics();
70 return scoped_ptr<DeviceInfo> (
71 new DeviceInfo(specifics.cache_guid(),
72 specifics.client_name(),
73 specifics.chrome_version(),
74 specifics.sync_user_agent(),
75 specifics.device_type()));
76 }
77
ReadDeviceInfo(const std::string & client_id) const78 scoped_ptr<DeviceInfo> SyncedDeviceTracker::ReadDeviceInfo(
79 const std::string& client_id) const {
80 syncer::ReadTransaction trans(FROM_HERE, user_share_);
81 syncer::ReadNode node(&trans);
82 std::string lookup_string = DeviceInfoLookupString(client_id);
83 if (node.InitByClientTagLookup(syncer::DEVICE_INFO, lookup_string) !=
84 syncer::BaseNode::INIT_OK) {
85 return scoped_ptr<DeviceInfo>();
86 }
87
88 const sync_pb::DeviceInfoSpecifics& specifics = node.GetDeviceInfoSpecifics();
89 return scoped_ptr<DeviceInfo> (
90 new DeviceInfo(specifics.cache_guid(),
91 specifics.client_name(),
92 specifics.chrome_version(),
93 specifics.sync_user_agent(),
94 specifics.device_type()));
95 }
96
GetAllSyncedDeviceInfo(ScopedVector<DeviceInfo> * device_info) const97 void SyncedDeviceTracker::GetAllSyncedDeviceInfo(
98 ScopedVector<DeviceInfo>* device_info) const {
99 if (device_info == NULL)
100 return;
101
102 device_info->clear();
103
104 syncer::ReadTransaction trans(FROM_HERE, user_share_);
105 syncer::ReadNode root_node(&trans);
106
107 if (root_node.InitByTagLookup(
108 syncer::ModelTypeToRootTag(syncer::DEVICE_INFO)) !=
109 syncer::BaseNode::INIT_OK) {
110 return;
111 }
112
113 // Get all the children of the root node and use the child id to read
114 // device info for devices.
115 std::vector<int64> children;
116 root_node.GetChildIds(&children);
117
118 for (std::vector<int64>::const_iterator it = children.begin();
119 it != children.end(); ++it) {
120 syncer::ReadNode node(&trans);
121 if (node.InitByIdLookup(*it) != syncer::BaseNode::INIT_OK)
122 return;
123
124 const sync_pb::DeviceInfoSpecifics& specifics =
125 node.GetDeviceInfoSpecifics();
126 device_info->push_back(
127 new DeviceInfo(specifics.cache_guid(),
128 specifics.client_name(),
129 specifics.chrome_version(),
130 specifics.sync_user_agent(),
131 specifics.device_type()));
132
133 }
134 }
135
cache_guid() const136 std::string SyncedDeviceTracker::cache_guid() const {
137 return cache_guid_;
138 }
139
AddObserver(Observer * observer)140 void SyncedDeviceTracker::AddObserver(Observer* observer) {
141 observers_->AddObserver(observer);
142 }
143
RemoveObserver(Observer * observer)144 void SyncedDeviceTracker::RemoveObserver(Observer* observer) {
145 observers_->RemoveObserver(observer);
146 }
147
InitLocalDeviceInfo(const base::Closure & callback)148 void SyncedDeviceTracker::InitLocalDeviceInfo(const base::Closure& callback) {
149 DeviceInfo::CreateLocalDeviceInfo(
150 cache_guid_,
151 base::Bind(&SyncedDeviceTracker::InitLocalDeviceInfoContinuation,
152 weak_factory_.GetWeakPtr(), callback));
153 }
154
InitLocalDeviceInfoContinuation(const base::Closure & callback,const DeviceInfo & local_info)155 void SyncedDeviceTracker::InitLocalDeviceInfoContinuation(
156 const base::Closure& callback, const DeviceInfo& local_info) {
157 WriteLocalDeviceInfo(local_info);
158 callback.Run();
159 }
160
WriteLocalDeviceInfo(const DeviceInfo & info)161 void SyncedDeviceTracker::WriteLocalDeviceInfo(const DeviceInfo& info) {
162 sync_pb::DeviceInfoSpecifics specifics;
163 DCHECK_EQ(cache_guid_, info.guid());
164 specifics.set_cache_guid(cache_guid_);
165 specifics.set_client_name(info.client_name());
166 specifics.set_chrome_version(info.chrome_version());
167 specifics.set_sync_user_agent(info.sync_user_agent());
168 specifics.set_device_type(info.device_type());
169
170 WriteDeviceInfo(specifics, local_device_info_tag_);
171 }
172
WriteDeviceInfo(const sync_pb::DeviceInfoSpecifics & specifics,const std::string & tag)173 void SyncedDeviceTracker::WriteDeviceInfo(
174 const sync_pb::DeviceInfoSpecifics& specifics,
175 const std::string& tag) {
176 syncer::WriteTransaction trans(FROM_HERE, user_share_);
177 syncer::WriteNode node(&trans);
178
179 if (node.InitByClientTagLookup(syncer::DEVICE_INFO, tag) ==
180 syncer::BaseNode::INIT_OK) {
181 node.SetDeviceInfoSpecifics(specifics);
182 node.SetTitle(UTF8ToWide(specifics.client_name()));
183 } else {
184 syncer::ReadNode type_root(&trans);
185 syncer::BaseNode::InitByLookupResult type_root_lookup_result =
186 type_root.InitByTagLookup(ModelTypeToRootTag(syncer::DEVICE_INFO));
187 DCHECK_EQ(syncer::BaseNode::INIT_OK, type_root_lookup_result);
188
189 syncer::WriteNode new_node(&trans);
190 syncer::WriteNode::InitUniqueByCreationResult create_result =
191 new_node.InitUniqueByCreation(syncer::DEVICE_INFO,
192 type_root,
193 tag);
194 DCHECK_EQ(syncer::WriteNode::INIT_SUCCESS, create_result);
195 new_node.SetDeviceInfoSpecifics(specifics);
196 new_node.SetTitle(UTF8ToWide(specifics.client_name()));
197 }
198 }
199
200 } // namespace browser_sync
201