Fix syncing of sessions. Numerous changes have been made. Currently, the mode...

chrome/browser/sync/profile_sync_service_session_unittest.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <map>
 #include <string>
 
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/scoped_temp_dir.h"
@@ skipping 38 matching lines @@
 using browser_sync::TestIdFactory;
 
 namespace browser_sync {
 
 class ProfileSyncServiceSessionTest
     : public BrowserWithTestWindowTest,
       public NotificationObserver {
  public:
   ProfileSyncServiceSessionTest()
       : window_bounds_(0, 1, 2, 3),
-        notified_of_update_(false),
-        notification_sync_id_(0) {}
+        notified_of_update_(false) {}
 
   ProfileSyncService* sync_service() { return sync_service_.get(); }
 
   TestIdFactory* ids() { return &ids_; }
 
  protected:
   SessionService* service() { return helper_.service(); }
 
   virtual void SetUp() {
     BrowserWithTestWindowTest::SetUp();
     profile()->set_has_history_service(true);
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     SessionService* session_service = new SessionService(temp_dir_.path());
     helper_.set_service(session_service);
     service()->SetWindowType(window_id_, Browser::TYPE_NORMAL);
     service()->SetWindowBounds(window_id_, window_bounds_, false);
     registrar_.Add(this, NotificationType::FOREIGN_SESSION_UPDATED,
         NotificationService::AllSources());
-    registrar_.Add(this, NotificationType::FOREIGN_SESSION_DELETED,
-        NotificationService::AllSources());
   }
 
   void Observe(NotificationType type,
       const NotificationSource& source,
       const NotificationDetails& details) {
     switch (type.value) {
-      case NotificationType::FOREIGN_SESSION_UPDATED: {
+      case NotificationType::FOREIGN_SESSION_UPDATED:
         notified_of_update_ = true;
-        notification_sync_id_ = *Details<int64>(details).ptr();
         break;
-      }
-      case NotificationType::FOREIGN_SESSION_DELETED: {
-        notified_of_update_ = true;
-        notification_sync_id_ = -1;
-        break;
-      }
       default:
         NOTREACHED();
         break;
     }
   }
 
   virtual void TearDown() {
     helper_.set_service(NULL);
     profile()->set_session_service(NULL);
     sync_service_.reset();
@@ skipping 33 matching lines @@
   ScopedTempDir temp_dir_;
   SessionServiceTestHelper helper_;
   SessionModelAssociator* model_associator_;
   SessionChangeProcessor* change_processor_;
   SessionID window_id_;
   ProfileSyncFactoryMock factory_;
   scoped_ptr<TestProfileSyncService> sync_service_;
   TestIdFactory ids_;
   const gfx::Rect window_bounds_;
   bool notified_of_update_;
-  int64 notification_sync_id_;
   NotificationRegistrar registrar_;
 };
 
 class CreateRootTask : public Task {
  public:
   explicit CreateRootTask(ProfileSyncServiceSessionTest* test)
       : test_(test), success_(false) {
   }
 
   virtual ~CreateRootTask() {}
@@ skipping 68 matching lines @@
   int64 sync_id;
   ASSERT_TRUE(model_associator_->GetSyncIdForTaggedNode(&machine_tag,
       &sync_id));
   ASSERT_EQ(model_associator_->GetSyncIdFromChromeId(machine_tag), sync_id);
   scoped_ptr<const sync_pb::SessionSpecifics> sync_specifics(
       model_associator_->GetChromeNodeFromSyncId(sync_id));
   ASSERT_TRUE(sync_specifics != NULL);
 
   // Check that this machine's data is not included in the foreign windows.
   ScopedVector<ForeignSession> foreign_sessions;
-  model_associator_->GetSessionDataFromSyncModel(&foreign_sessions.get());
+  model_associator_->GetSessionData(&foreign_sessions.get());
   ASSERT_EQ(foreign_sessions.size(), 0U);
 
   // Get the windows for this machine from the node and check that they were
   // filled.
   sync_api::ReadTransaction trans(sync_service_->
       backend()->GetUserShareHandle());
   sync_api::ReadNode node(&trans);
   ASSERT_TRUE(node.InitByClientTagLookup(syncable::SESSIONS,
       machine_tag));
   model_associator_->AppendForeignSessionWithID(sync_id,
@@ skipping 52 matching lines @@
   navigation->set_title("title");
   navigation->set_page_transition(sync_pb::TabNavigation_PageTransition_TYPED);
 
   // Update the server with the session specifics.
   {
     sync_api::WriteTransaction trans(sync_service_->
         backend()->GetUserShareHandle());
     sync_api::ReadNode root(&trans);
     ASSERT_TRUE(root.InitByTagLookup(kSessionsTag));
     model_associator_->UpdateSyncModel(&specifics, &trans, &root);
+    model_associator_->UpdateFromSyncModel(&trans);
   }
 
   // Check that the foreign session was written to a node and retrieve the data.
   int64 sync_id;
   ASSERT_TRUE(model_associator_->GetSyncIdForTaggedNode(&machine_tag,
       &sync_id));
   ASSERT_EQ(model_associator_->GetSyncIdFromChromeId(machine_tag), sync_id);
   scoped_ptr<const sync_pb::SessionSpecifics> sync_specifics(
       model_associator_->GetChromeNodeFromSyncId(sync_id));
   ASSERT_TRUE(sync_specifics != NULL);
   ScopedVector<ForeignSession> foreign_sessions;
-  model_associator_->GetSessionDataFromSyncModel(&foreign_sessions.get());
-  ASSERT_EQ(foreign_sessions.size(), 1U);
+  model_associator_->GetSessionData(&foreign_sessions.get());
+  ASSERT_EQ(1U, foreign_sessions.size());
   ASSERT_EQ(1U,  foreign_sessions[0]->windows.size());
   ASSERT_EQ(1U, foreign_sessions[0]->windows[0]->tabs.size());
   ASSERT_EQ(1U, foreign_sessions[0]->windows[0]->tabs[0]->navigations.size());
   ASSERT_EQ(foreign_sessions[0]->foreign_tession_tag, machine_tag);
   ASSERT_EQ(1, foreign_sessions[0]->windows[0]->selected_tab_index);
   ASSERT_EQ(1, foreign_sessions[0]->windows[0]->type);
   ASSERT_EQ(13, foreign_sessions[0]->windows[0]->tabs[0]->tab_visual_index);
   ASSERT_EQ(3,
       foreign_sessions[0]->windows[0]->tabs[0]->current_navigation_index);
   ASSERT_TRUE(foreign_sessions[0]->windows[0]->tabs[0]->pinned);
@@ skipping 22 matching lines @@
 // Test the DataTypeController on update.
 TEST_F(ProfileSyncServiceSessionTest, UpdatedSyncNodeActionUpdate) {
   CreateRootTask task(this);
   ASSERT_TRUE(StartSyncService(&task, false));
   ASSERT_TRUE(task.success());
   int64 node_id = model_associator_->GetSyncIdFromChromeId(
       model_associator_->GetCurrentMachineTag());
   scoped_ptr<SyncManager::ChangeRecord> record(new SyncManager::ChangeRecord);
   record->action = SyncManager::ChangeRecord::ACTION_UPDATE;
   record->id = node_id;
-  ASSERT_EQ(notification_sync_id_, 0);
   ASSERT_FALSE(notified_of_update_);
   {
     sync_api::WriteTransaction trans(backend()->GetUserShareHandle());
     change_processor_->ApplyChangesFromSyncModel(&trans, record.get(), 1);
   }
-  ASSERT_EQ(notification_sync_id_, node_id);
   ASSERT_TRUE(notified_of_update_);
 }
 
 // Test the DataTypeController on add.
 TEST_F(ProfileSyncServiceSessionTest, UpdatedSyncNodeActionAdd) {
   CreateRootTask task(this);
   ASSERT_TRUE(StartSyncService(&task, false));
   ASSERT_TRUE(task.success());
 
   int64 node_id = model_associator_->GetSyncIdFromChromeId(
       model_associator_->GetCurrentMachineTag());
   scoped_ptr<SyncManager::ChangeRecord> record(new SyncManager::ChangeRecord);
   record->action = SyncManager::ChangeRecord::ACTION_ADD;
   record->id = node_id;
-  ASSERT_EQ(notification_sync_id_, 0);
   ASSERT_FALSE(notified_of_update_);
   {
     sync_api::WriteTransaction trans(backend()->GetUserShareHandle());
     change_processor_->ApplyChangesFromSyncModel(&trans, record.get(), 1);
   }
-  ASSERT_EQ(notification_sync_id_, node_id);
   ASSERT_TRUE(notified_of_update_);
 }
 
 // Test the DataTypeController on delete.
 TEST_F(ProfileSyncServiceSessionTest, UpdatedSyncNodeActionDelete) {
   CreateRootTask task(this);
   ASSERT_TRUE(StartSyncService(&task, false));
   ASSERT_TRUE(task.success());
 
   int64 node_id = model_associator_->GetSyncIdFromChromeId(
       model_associator_->GetCurrentMachineTag());
   scoped_ptr<SyncManager::ChangeRecord> record(new SyncManager::ChangeRecord);
   record->action = SyncManager::ChangeRecord::ACTION_DELETE;
   record->id = node_id;
-  ASSERT_EQ(notification_sync_id_, 0);
   ASSERT_FALSE(notified_of_update_);
   {
     sync_api::WriteTransaction trans(backend()->GetUserShareHandle());
     change_processor_->ApplyChangesFromSyncModel(&trans, record.get(), 1);
   }
-  ASSERT_EQ(notification_sync_id_, -1);
   ASSERT_TRUE(notified_of_update_);
 }
 
 }  // namespace browser_sync