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 |