| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2010 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 <map> | |
| 6 #include <string> | |
| 7 | |
| 8 #include "base/message_loop.h" | |
| 9 #include "base/scoped_ptr.h" | |
| 10 #include "base/scoped_temp_dir.h" | |
| 11 #include "base/stl_util-inl.h" | |
| 12 #include "base/task.h" | |
| 13 #include "chrome/browser/sessions/session_service.h" | |
| 14 #include "chrome/browser/sessions/session_service_test_helper.h" | |
| 15 #include "chrome/browser/sync/abstract_profile_sync_service_test.h" | |
| 16 #include "chrome/browser/sync/engine/syncapi.h" | |
| 17 #include "chrome/browser/sync/glue/session_change_processor.h" | |
| 18 #include "chrome/browser/sync/glue/session_data_type_controller.h" | |
| 19 #include "chrome/browser/sync/glue/session_model_associator.h" | |
| 20 #include "chrome/browser/sync/glue/sync_backend_host.h" | |
| 21 #include "chrome/browser/sync/profile_sync_test_util.h" | |
| 22 #include "chrome/browser/sync/profile_sync_factory_mock.h" | |
| 23 #include "chrome/browser/sync/protocol/session_specifics.pb.h" | |
| 24 #include "chrome/browser/sync/protocol/sync.pb.h" | |
| 25 #include "chrome/browser/sync/syncable/directory_manager.h" | |
| 26 #include "chrome/browser/sync/syncable/model_type.h" | |
| 27 #include "chrome/browser/sync/syncable/syncable.h" | |
| 28 #include "chrome/browser/sync/test_profile_sync_service.h" | |
| 29 #include "chrome/common/notification_observer.h" | |
| 30 #include "chrome/common/notification_registrar.h" | |
| 31 #include "chrome/common/notification_service.h" | |
| 32 #include "chrome/common/pref_names.h" | |
| 33 #include "chrome/test/browser_with_test_window_test.h" | |
| 34 #include "chrome/test/file_test_utils.h" | |
| 35 #include "chrome/test/profile_mock.h" | |
| 36 #include "chrome/test/testing_profile.h" | |
| 37 #include "chrome/test/sync/engine/test_id_factory.h" | |
| 38 #include "testing/gmock/include/gmock/gmock.h" | |
| 39 #include "testing/gtest/include/gtest/gtest.h" | |
| 40 | |
| 41 using browser_sync::SessionChangeProcessor; | |
| 42 using browser_sync::SessionDataTypeController; | |
| 43 using browser_sync::SessionModelAssociator; | |
| 44 using browser_sync::SyncBackendHost; | |
| 45 using sync_api::SyncManager; | |
| 46 using testing::_; | |
| 47 using testing::Return; | |
| 48 using browser_sync::TestIdFactory; | |
| 49 | |
| 50 namespace browser_sync { | |
| 51 | |
| 52 class ProfileSyncServiceSessionTest | |
| 53 : public BrowserWithTestWindowTest, | |
| 54 public NotificationObserver { | |
| 55 public: | |
| 56 ProfileSyncServiceSessionTest() | |
| 57 : window_bounds_(0, 1, 2, 3), | |
| 58 notified_of_update_(false), | |
| 59 notification_sync_id_(0) {} | |
| 60 | |
| 61 ProfileSyncService* sync_service() { return sync_service_.get(); } | |
| 62 | |
| 63 TestIdFactory* ids() { return &ids_; } | |
| 64 | |
| 65 protected: | |
| 66 SessionService* service() { return helper_.service(); } | |
| 67 | |
| 68 virtual void SetUp() { | |
| 69 BrowserWithTestWindowTest::SetUp(); | |
| 70 profile()->set_has_history_service(true); | |
| 71 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); | |
| 72 SessionService* session_service = new SessionService(temp_dir_.path()); | |
| 73 helper_.set_service(session_service); | |
| 74 service()->SetWindowType(window_id_, Browser::TYPE_NORMAL); | |
| 75 service()->SetWindowBounds(window_id_, window_bounds_, false); | |
| 76 registrar_.Add(this, NotificationType::FOREIGN_SESSION_UPDATED, | |
| 77 NotificationService::AllSources()); | |
| 78 registrar_.Add(this, NotificationType::FOREIGN_SESSION_DELETED, | |
| 79 NotificationService::AllSources()); | |
| 80 } | |
| 81 | |
| 82 void Observe(NotificationType type, | |
| 83 const NotificationSource& source, | |
| 84 const NotificationDetails& details) { | |
| 85 switch (type.value) { | |
| 86 case NotificationType::FOREIGN_SESSION_UPDATED: { | |
| 87 notified_of_update_ = true; | |
| 88 notification_sync_id_ = *Details<int64>(details).ptr(); | |
| 89 break; | |
| 90 } | |
| 91 case NotificationType::FOREIGN_SESSION_DELETED: { | |
| 92 notified_of_update_ = true; | |
| 93 notification_sync_id_ = -1; | |
| 94 break; | |
| 95 } | |
| 96 default: | |
| 97 NOTREACHED(); | |
| 98 break; | |
| 99 } | |
| 100 } | |
| 101 | |
| 102 virtual void TearDown() { | |
| 103 helper_.set_service(NULL); | |
| 104 profile()->set_session_service(NULL); | |
| 105 sync_service_.reset(); | |
| 106 } | |
| 107 | |
| 108 bool StartSyncService(Task* task, bool will_fail_association) { | |
| 109 if (sync_service_.get()) | |
| 110 return false; | |
| 111 | |
| 112 sync_service_.reset(new TestProfileSyncService( | |
| 113 &factory_, profile(), false, false, task)); | |
| 114 profile()->set_session_service(helper_.service()); | |
| 115 | |
| 116 // Register the session data type. | |
| 117 model_associator_ = | |
| 118 new SessionModelAssociator(sync_service_.get()); | |
| 119 change_processor_ = new SessionChangeProcessor( | |
| 120 sync_service_.get(), model_associator_); | |
| 121 EXPECT_CALL(factory_, CreateSessionSyncComponents(_, _)). | |
| 122 WillOnce(Return(ProfileSyncFactory::SyncComponents( | |
| 123 model_associator_, change_processor_))); | |
| 124 EXPECT_CALL(factory_, CreateDataTypeManager(_, _)). | |
| 125 WillOnce(ReturnNewDataTypeManager()); | |
| 126 sync_service_->set_num_expected_resumes(will_fail_association ? 0 : 1); | |
| 127 sync_service_->RegisterDataTypeController( | |
| 128 new SessionDataTypeController(&factory_, sync_service_.get())); | |
| 129 sync_service_->Initialize(); | |
| 130 MessageLoop::current()->Run(); | |
| 131 return true; | |
| 132 } | |
| 133 | |
| 134 SyncBackendHost* backend() { return sync_service_->backend(); } | |
| 135 | |
| 136 // Path used in testing. | |
| 137 ScopedTempDir temp_dir_; | |
| 138 SessionServiceTestHelper helper_; | |
| 139 SessionModelAssociator* model_associator_; | |
| 140 SessionChangeProcessor* change_processor_; | |
| 141 SessionID window_id_; | |
| 142 ProfileSyncFactoryMock factory_; | |
| 143 scoped_ptr<TestProfileSyncService> sync_service_; | |
| 144 TestIdFactory ids_; | |
| 145 const gfx::Rect window_bounds_; | |
| 146 bool notified_of_update_; | |
| 147 int64 notification_sync_id_; | |
| 148 NotificationRegistrar registrar_; | |
| 149 }; | |
| 150 | |
| 151 class CreateRootTask : public Task { | |
| 152 public: | |
| 153 explicit CreateRootTask(ProfileSyncServiceSessionTest* test) | |
| 154 : test_(test), success_(false) { | |
| 155 } | |
| 156 | |
| 157 virtual ~CreateRootTask() {} | |
| 158 virtual void Run() { | |
| 159 success_ = ProfileSyncServiceTestHelper::CreateRoot(syncable::SESSIONS, | |
| 160 test_->sync_service(), test_->ids()); | |
| 161 } | |
| 162 | |
| 163 bool success() { return success_; } | |
| 164 | |
| 165 private: | |
| 166 ProfileSyncServiceSessionTest* test_; | |
| 167 bool success_; | |
| 168 }; | |
| 169 | |
| 170 // Test that we can write this machine's session to a node and retrieve it. | |
| 171 TEST_F(ProfileSyncServiceSessionTest, WriteSessionToNode) { | |
| 172 CreateRootTask task(this); | |
| 173 ASSERT_TRUE(StartSyncService(&task, false)); | |
| 174 ASSERT_TRUE(task.success()); | |
| 175 ASSERT_EQ(model_associator_->GetSessionService(), helper_.service()); | |
| 176 | |
| 177 // Check that the DataTypeController associated the models. | |
| 178 bool has_nodes; | |
| 179 ASSERT_TRUE(model_associator_->SyncModelHasUserCreatedNodes(&has_nodes)); | |
| 180 ASSERT_TRUE(has_nodes); | |
| 181 ASSERT_TRUE(model_associator_->ChromeModelHasUserCreatedNodes(&has_nodes)); | |
| 182 ASSERT_TRUE(has_nodes); | |
| 183 std::string machine_tag = model_associator_->GetCurrentMachineTag(); | |
| 184 int64 sync_id; | |
| 185 ASSERT_TRUE(model_associator_->GetSyncIdForTaggedNode(&machine_tag, | |
| 186 &sync_id)); | |
| 187 ASSERT_EQ(model_associator_->GetSyncIdFromChromeId(machine_tag), sync_id); | |
| 188 scoped_ptr<const sync_pb::SessionSpecifics> sync_specifics( | |
| 189 model_associator_->GetChromeNodeFromSyncId(sync_id)); | |
| 190 ASSERT_TRUE(sync_specifics != NULL); | |
| 191 | |
| 192 // Check that we can get the correct session specifics back from the node. | |
| 193 sync_api::ReadTransaction trans(sync_service_-> | |
| 194 backend()->GetUserShareHandle()); | |
| 195 sync_api::ReadNode node(&trans); | |
| 196 ASSERT_TRUE(node.InitByClientTagLookup(syncable::SESSIONS, | |
| 197 machine_tag)); | |
| 198 const sync_pb::SessionSpecifics& specifics(node.GetSessionSpecifics()); | |
| 199 ASSERT_EQ(sync_specifics->session_tag(), specifics.session_tag()); | |
| 200 ASSERT_EQ(machine_tag, specifics.session_tag()); | |
| 201 } | |
| 202 | |
| 203 // Test that we can fill this machine's session, write it to a node, | |
| 204 // and then retrieve it. | |
| 205 TEST_F(ProfileSyncServiceSessionTest, WriteFilledSessionToNode) { | |
| 206 CreateRootTask task(this); | |
| 207 ASSERT_TRUE(StartSyncService(&task, false)); | |
| 208 ASSERT_TRUE(task.success()); | |
| 209 | |
| 210 // Check that the DataTypeController associated the models. | |
| 211 bool has_nodes; | |
| 212 ASSERT_TRUE(model_associator_->SyncModelHasUserCreatedNodes(&has_nodes)); | |
| 213 ASSERT_TRUE(has_nodes); | |
| 214 AddTab(browser(), GURL("http://foo/1")); | |
| 215 NavigateAndCommitActiveTab(GURL("http://foo/2")); | |
| 216 AddTab(browser(), GURL("http://bar/1")); | |
| 217 NavigateAndCommitActiveTab(GURL("http://bar/2")); | |
| 218 | |
| 219 // Report a saved session, thus causing the ChangeProcessor to write to a | |
| 220 // node. | |
| 221 NotificationService::current()->Notify( | |
| 222 NotificationType::SESSION_SERVICE_SAVED, | |
| 223 Source<Profile>(profile()), | |
| 224 NotificationService::NoDetails()); | |
| 225 std::string machine_tag = model_associator_->GetCurrentMachineTag(); | |
| 226 int64 sync_id; | |
| 227 ASSERT_TRUE(model_associator_->GetSyncIdForTaggedNode(&machine_tag, | |
| 228 &sync_id)); | |
| 229 ASSERT_EQ(model_associator_->GetSyncIdFromChromeId(machine_tag), sync_id); | |
| 230 scoped_ptr<const sync_pb::SessionSpecifics> sync_specifics( | |
| 231 model_associator_->GetChromeNodeFromSyncId(sync_id)); | |
| 232 ASSERT_TRUE(sync_specifics != NULL); | |
| 233 | |
| 234 // Check that this machine's data is not included in the foreign windows. | |
| 235 std::vector<ForeignSession*> foreign_sessions; | |
| 236 model_associator_->GetSessionDataFromSyncModel(&foreign_sessions); | |
| 237 ASSERT_EQ(foreign_sessions.size(), 0U); | |
| 238 | |
| 239 // Get the windows for this machine from the node and check that they were | |
| 240 // filled. | |
| 241 sync_api::ReadTransaction trans(sync_service_-> | |
| 242 backend()->GetUserShareHandle()); | |
| 243 sync_api::ReadNode node(&trans); | |
| 244 ASSERT_TRUE(node.InitByClientTagLookup(syncable::SESSIONS, | |
| 245 machine_tag)); | |
| 246 model_associator_->AppendForeignSessionWithID(sync_id, &foreign_sessions, | |
| 247 &trans); | |
| 248 ASSERT_EQ(foreign_sessions.size(), 1U); | |
| 249 ASSERT_EQ(1U, foreign_sessions[0]->windows.size()); | |
| 250 ASSERT_EQ(2U, foreign_sessions[0]->windows[0]->tabs.size()); | |
| 251 ASSERT_EQ(2U, foreign_sessions[0]->windows[0]->tabs[0]->navigations.size()); | |
| 252 ASSERT_EQ(GURL("http://bar/1"), | |
| 253 foreign_sessions[0]->windows[0]->tabs[0]->navigations[0].virtual_url()); | |
| 254 ASSERT_EQ(GURL("http://bar/2"), | |
| 255 foreign_sessions[0]->windows[0]->tabs[0]->navigations[1].virtual_url()); | |
| 256 ASSERT_EQ(2U, foreign_sessions[0]->windows[0]->tabs[1]->navigations.size()); | |
| 257 ASSERT_EQ(GURL("http://foo/1"), | |
| 258 foreign_sessions[0]->windows[0]->tabs[1]->navigations[0].virtual_url()); | |
| 259 ASSERT_EQ(GURL("http://foo/2"), | |
| 260 foreign_sessions[0]->windows[0]->tabs[1]->navigations[1].virtual_url()); | |
| 261 const sync_pb::SessionSpecifics& specifics(node.GetSessionSpecifics()); | |
| 262 ASSERT_EQ(sync_specifics->session_tag(), specifics.session_tag()); | |
| 263 ASSERT_EQ(machine_tag, specifics.session_tag()); | |
| 264 } | |
| 265 | |
| 266 // Test that we fail on a failed model association. | |
| 267 TEST_F(ProfileSyncServiceSessionTest, FailModelAssociation) { | |
| 268 ASSERT_TRUE(StartSyncService(NULL, true)); | |
| 269 ASSERT_TRUE(sync_service_->unrecoverable_error_detected()); | |
| 270 } | |
| 271 | |
| 272 // Write a foreign session to a node, and then retrieve it. | |
| 273 TEST_F(ProfileSyncServiceSessionTest, WriteForeignSessionToNode) { | |
| 274 CreateRootTask task(this); | |
| 275 ASSERT_TRUE(StartSyncService(&task, false)); | |
| 276 ASSERT_TRUE(task.success()); | |
| 277 | |
| 278 // Check that the DataTypeController associated the models. | |
| 279 bool has_nodes; | |
| 280 ASSERT_TRUE(model_associator_->SyncModelHasUserCreatedNodes(&has_nodes)); | |
| 281 ASSERT_TRUE(has_nodes); | |
| 282 | |
| 283 // Fill an instance of session specifics with a foreign session's data. | |
| 284 sync_pb::SessionSpecifics specifics; | |
| 285 std::string machine_tag = "session_sync123"; | |
| 286 specifics.set_session_tag(machine_tag); | |
| 287 sync_pb::SessionWindow* window = specifics.add_session_window(); | |
| 288 window->set_selected_tab_index(1); | |
| 289 window->set_browser_type(sync_pb::SessionWindow_BrowserType_TYPE_NORMAL); | |
| 290 sync_pb::SessionTab* tab = window->add_session_tab(); | |
| 291 tab->set_tab_visual_index(13); | |
| 292 tab->set_current_navigation_index(3); | |
| 293 tab->set_pinned(true); | |
| 294 tab->set_extension_app_id("app_id"); | |
| 295 sync_pb::TabNavigation* navigation = tab->add_navigation(); | |
| 296 navigation->set_index(12); | |
| 297 navigation->set_virtual_url("http://foo/1"); | |
| 298 navigation->set_referrer("referrer"); | |
| 299 navigation->set_title("title"); | |
| 300 navigation->set_page_transition(sync_pb::TabNavigation_PageTransition_TYPED); | |
| 301 | |
| 302 // Update the server with the session specifics. | |
| 303 { | |
| 304 sync_api::WriteTransaction trans(sync_service_-> | |
| 305 backend()->GetUserShareHandle()); | |
| 306 sync_api::ReadNode root(&trans); | |
| 307 ASSERT_TRUE(root.InitByTagLookup(kSessionsTag)); | |
| 308 model_associator_->UpdateSyncModel(&specifics, &trans, &root); | |
| 309 } | |
| 310 | |
| 311 // Check that the foreign session was written to a node and retrieve the data. | |
| 312 int64 sync_id; | |
| 313 ASSERT_TRUE(model_associator_->GetSyncIdForTaggedNode(&machine_tag, | |
| 314 &sync_id)); | |
| 315 ASSERT_EQ(model_associator_->GetSyncIdFromChromeId(machine_tag), sync_id); | |
| 316 scoped_ptr<const sync_pb::SessionSpecifics> sync_specifics( | |
| 317 model_associator_->GetChromeNodeFromSyncId(sync_id)); | |
| 318 ASSERT_TRUE(sync_specifics != NULL); | |
| 319 std::vector<ForeignSession*> foreign_sessions; | |
| 320 model_associator_->GetSessionDataFromSyncModel(&foreign_sessions); | |
| 321 ASSERT_EQ(foreign_sessions.size(), 1U); | |
| 322 ASSERT_EQ(1U, foreign_sessions[0]->windows.size()); | |
| 323 ASSERT_EQ(1U, foreign_sessions[0]->windows[0]->tabs.size()); | |
| 324 ASSERT_EQ(1U, foreign_sessions[0]->windows[0]->tabs[0]->navigations.size()); | |
| 325 ASSERT_EQ(foreign_sessions[0]->foreign_tession_tag, machine_tag); | |
| 326 ASSERT_EQ(1, foreign_sessions[0]->windows[0]->selected_tab_index); | |
| 327 ASSERT_EQ(1, foreign_sessions[0]->windows[0]->type); | |
| 328 ASSERT_EQ(13, foreign_sessions[0]->windows[0]->tabs[0]->tab_visual_index); | |
| 329 ASSERT_EQ(3, | |
| 330 foreign_sessions[0]->windows[0]->tabs[0]->current_navigation_index); | |
| 331 ASSERT_TRUE(foreign_sessions[0]->windows[0]->tabs[0]->pinned); | |
| 332 ASSERT_EQ("app_id", | |
| 333 foreign_sessions[0]->windows[0]->tabs[0]->extension_app_id); | |
| 334 ASSERT_EQ(12, | |
| 335 foreign_sessions[0]->windows[0]->tabs[0]->navigations[0].index()); | |
| 336 ASSERT_EQ(GURL("referrer"), | |
| 337 foreign_sessions[0]->windows[0]->tabs[0]->navigations[0].referrer()); | |
| 338 ASSERT_EQ(string16(ASCIIToUTF16("title")), | |
| 339 foreign_sessions[0]->windows[0]->tabs[0]->navigations[0].title()); | |
| 340 ASSERT_EQ(PageTransition::TYPED, | |
| 341 foreign_sessions[0]->windows[0]->tabs[0]->navigations[0].transition()); | |
| 342 ASSERT_EQ(GURL("http://foo/1"), | |
| 343 foreign_sessions[0]->windows[0]->tabs[0]->navigations[0].virtual_url()); | |
| 344 sync_api::WriteTransaction trans(sync_service_-> | |
| 345 backend()->GetUserShareHandle()); | |
| 346 sync_api::ReadNode node(&trans); | |
| 347 ASSERT_TRUE(node.InitByClientTagLookup(syncable::SESSIONS, | |
| 348 machine_tag)); | |
| 349 const sync_pb::SessionSpecifics& specifics_(node.GetSessionSpecifics()); | |
| 350 ASSERT_EQ(sync_specifics->session_tag(), specifics_.session_tag()); | |
| 351 ASSERT_EQ(machine_tag, specifics_.session_tag()); | |
| 352 } | |
| 353 | |
| 354 // Test the DataTypeController on update. | |
| 355 TEST_F(ProfileSyncServiceSessionTest, UpdatedSyncNodeActionUpdate) { | |
| 356 CreateRootTask task(this); | |
| 357 ASSERT_TRUE(StartSyncService(&task, false)); | |
| 358 ASSERT_TRUE(task.success()); | |
| 359 int64 node_id = model_associator_->GetSyncIdFromChromeId( | |
| 360 model_associator_->GetCurrentMachineTag()); | |
| 361 scoped_ptr<SyncManager::ChangeRecord> record(new SyncManager::ChangeRecord); | |
| 362 record->action = SyncManager::ChangeRecord::ACTION_UPDATE; | |
| 363 record->id = node_id; | |
| 364 ASSERT_EQ(notification_sync_id_, 0); | |
| 365 ASSERT_FALSE(notified_of_update_); | |
| 366 { | |
| 367 sync_api::WriteTransaction trans(backend()->GetUserShareHandle()); | |
| 368 change_processor_->ApplyChangesFromSyncModel(&trans, record.get(), 1); | |
| 369 } | |
| 370 ASSERT_EQ(notification_sync_id_, node_id); | |
| 371 ASSERT_TRUE(notified_of_update_); | |
| 372 } | |
| 373 | |
| 374 // Test the DataTypeController on add. | |
| 375 TEST_F(ProfileSyncServiceSessionTest, UpdatedSyncNodeActionAdd) { | |
| 376 CreateRootTask task(this); | |
| 377 ASSERT_TRUE(StartSyncService(&task, false)); | |
| 378 ASSERT_TRUE(task.success()); | |
| 379 | |
| 380 int64 node_id = model_associator_->GetSyncIdFromChromeId( | |
| 381 model_associator_->GetCurrentMachineTag()); | |
| 382 scoped_ptr<SyncManager::ChangeRecord> record(new SyncManager::ChangeRecord); | |
| 383 record->action = SyncManager::ChangeRecord::ACTION_ADD; | |
| 384 record->id = node_id; | |
| 385 ASSERT_EQ(notification_sync_id_, 0); | |
| 386 ASSERT_FALSE(notified_of_update_); | |
| 387 { | |
| 388 sync_api::WriteTransaction trans(backend()->GetUserShareHandle()); | |
| 389 change_processor_->ApplyChangesFromSyncModel(&trans, record.get(), 1); | |
| 390 } | |
| 391 ASSERT_EQ(notification_sync_id_, node_id); | |
| 392 ASSERT_TRUE(notified_of_update_); | |
| 393 } | |
| 394 | |
| 395 // Test the DataTypeController on delete. | |
| 396 TEST_F(ProfileSyncServiceSessionTest, UpdatedSyncNodeActionDelete) { | |
| 397 CreateRootTask task(this); | |
| 398 ASSERT_TRUE(StartSyncService(&task, false)); | |
| 399 ASSERT_TRUE(task.success()); | |
| 400 | |
| 401 int64 node_id = model_associator_->GetSyncIdFromChromeId( | |
| 402 model_associator_->GetCurrentMachineTag()); | |
| 403 scoped_ptr<SyncManager::ChangeRecord> record(new SyncManager::ChangeRecord); | |
| 404 record->action = SyncManager::ChangeRecord::ACTION_DELETE; | |
| 405 record->id = node_id; | |
| 406 ASSERT_EQ(notification_sync_id_, 0); | |
| 407 ASSERT_FALSE(notified_of_update_); | |
| 408 { | |
| 409 sync_api::WriteTransaction trans(backend()->GetUserShareHandle()); | |
| 410 change_processor_->ApplyChangesFromSyncModel(&trans, record.get(), 1); | |
| 411 } | |
| 412 ASSERT_EQ(notification_sync_id_, -1); | |
| 413 ASSERT_TRUE(notified_of_update_); | |
| 414 } | |
| 415 | |
| 416 } // namespace browser_sync | |
| 417 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 3127017:
Revert 56423 - Added classes to enable session sync functionality.... (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src/