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

chrome/browser/dom_ui/foreign_session_handler.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 "chrome/browser/dom_ui/foreign_session_handler.h"
 
 #include "base/scoped_vector.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/dom_ui/value_helper.h"
@@ skipping 17 matching lines @@
   dom_ui_->RegisterMessageCallback("getForeignSessions",
       NewCallback(this,
       &ForeignSessionHandler::HandleGetForeignSessions));
   dom_ui_->RegisterMessageCallback("reopenForeignSession",
       NewCallback(this,
       &ForeignSessionHandler::HandleReopenForeignSession));
 }
 
 void ForeignSessionHandler::Init() {
   registrar_.Add(this, NotificationType::SYNC_CONFIGURE_DONE,
-      NotificationService::AllSources());
+                 NotificationService::AllSources());
   registrar_.Add(this, NotificationType::FOREIGN_SESSION_UPDATED,
-      NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::FOREIGN_SESSION_DELETED,
-      NotificationService::AllSources());
+                 NotificationService::AllSources());
+  registrar_.Add(this, NotificationType::FOREIGN_SESSION_DISABLED,
+                 NotificationService::AllSources());
 }
 
 void ForeignSessionHandler::Observe(NotificationType type,
                                     const NotificationSource& source,
                                     const NotificationDetails& details) {
-  if (type != NotificationType::SYNC_CONFIGURE_DONE &&
-      type != NotificationType::FOREIGN_SESSION_UPDATED &&
-      type != NotificationType::FOREIGN_SESSION_DELETED) {
-    NOTREACHED();
-    return;
+  ListValue list_value;
+  switch (type.value) {
+    case NotificationType::SYNC_CONFIGURE_DONE:
+    case NotificationType::FOREIGN_SESSION_UPDATED:
+      HandleGetForeignSessions(&list_value);
+      break;
+    case NotificationType::FOREIGN_SESSION_DISABLED:
+      // Calling foreignSessions with empty list will automatically hide
+      // foreign session section.
+      dom_ui_->CallJavascriptFunction(L"foreignSessions", list_value);
+      break;
+    default:
+      NOTREACHED();
   }
-  ListValue list_value;
-  HandleGetForeignSessions(&list_value);
 }
 
 SessionModelAssociator* ForeignSessionHandler::GetModelAssociator() {
   ProfileSyncService* service = dom_ui_->GetProfile()->GetProfileSyncService();
   if (service == NULL)
     return NULL;
   // We only want to set the model associator if there is one, and it is done
   // syncing sessions.
   SessionModelAssociator* model_associator = service->
       GetSessionModelAssociator();
@@ skipping 33 matching lines @@
   ScopedVector<ForeignSession> session;
   associator->AppendForeignSessionWithID(id, &session.get(), &trans);
 
   DCHECK(session.size() == 1);
   std::vector<SessionWindow*> windows = (*session.begin())->windows;
   SessionRestore::RestoreForeignSessionWindows(dom_ui_->GetProfile(), &windows);
 }
 
 void ForeignSessionHandler::GetForeignSessions(
     SessionModelAssociator* associator) {
-  ScopedVector<ForeignSession> windows;
-  associator->GetSessionDataFromSyncModel(&windows.get());
+  ScopedVector<ForeignSession> clients;
+  if (!associator->GetSessionData(&clients.get())) {
+    LOG(ERROR) << "ForeignSessionHandler failed to get session data from"
+        "SessionModelAssociator.";
+    return;
+  }
   int added_count = 0;
-  ListValue list_value;
+  ListValue client_list;
   for (std::vector<ForeignSession*>::const_iterator i =
-      windows.begin(); i != windows.end() &&
+      clients->begin(); i != clients->end() &&
       added_count < kMaxSessionsToShow; ++i) {
     ForeignSession* foreign_session = *i;
     std::vector<TabRestoreService::Entry*> entries;
     dom_ui_->GetProfile()->GetTabRestoreService()->CreateEntriesFromWindows(
         &foreign_session->windows, &entries);
+    scoped_ptr<ListValue> window_list(new ListValue());
     for (std::vector<TabRestoreService::Entry*>::const_iterator it =
         entries.begin(); it != entries.end(); ++it) {
       TabRestoreService::Entry* entry = *it;
-      scoped_ptr<DictionaryValue> value(new DictionaryValue());
+      scoped_ptr<DictionaryValue> window_data(new DictionaryValue());
       if (entry->type == TabRestoreService::WINDOW &&
           ValueHelper::WindowToValue(
-              *static_cast<TabRestoreService::Window*>(entry), value.get())) {
+              *static_cast<TabRestoreService::Window*>(entry),
+              window_data.get())) {
         // The javascript checks if the session id is a valid session id,
         // when rendering session information to the new tab page, and it
         // sends the sessionTag back when we need to restore a session.
-        value->SetString("sessionTag", foreign_session->foreign_tession_tag);
-        value->SetInteger("sessionId", entry->id);
-        list_value.Append(value.release());  // Give ownership to |list_value|.
+
+        // TODO(zea): sessionTag is per client, it might be better per window.
+        window_data->SetString("sessionTag",
+            foreign_session->foreign_tession_tag);
+        window_data->SetInteger("sessionId", entry->id);
+
+        // Give ownership to |list_value|.
+        window_list->Append(window_data.release());
       }
     }
     added_count++;
+
+    // Give ownership to |client_list|
+    client_list.Append(window_list.release());
   }
-  dom_ui_->CallJavascriptFunction(L"foreignSessions", list_value);
+  dom_ui_->CallJavascriptFunction(L"foreignSessions", client_list);
 }
 
 }  // namespace browser_sync
-