sync: take two for: "Added classes to enable session sync...

chrome/browser/sync/glue/session_model_associator.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/sync/glue/session_model_associator.h"
+
+#include <utility>
+
+#include "base/logging.h"
+#include "base/string_util.h"
+#include "base/utf_string_conversions.h"
+#include "chrome/browser/profile.h"
+#include "chrome/browser/sessions/session_id.h"
+#include "chrome/browser/sync/profile_sync_service.h"
+#include "chrome/browser/sync/syncable/syncable.h"
+#include "chrome/common/notification_details.h"
+#include "chrome/common/notification_service.h"
+#include "chrome/common/url_constants.h"
+
+namespace browser_sync {
+
+namespace {
+
+static const char kNoSessionsFolderError[] =
+    "Server did not create the top-level sessions node. We "
+    "might be running against an out-of-date server.";
+
+}  // namespace
+
+SessionModelAssociator::SessionModelAssociator(
+    ProfileSyncService* sync_service) : sync_service_(sync_service) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(sync_service_);
+}
+
+SessionModelAssociator::~SessionModelAssociator() {
+  DCHECK(CalledOnValidThread());
+}
+
+// Sends a notification to ForeignSessionHandler to update the UI, because
+// the session corresponding to the id given has changed state.
+void SessionModelAssociator::Associate(
+    const sync_pb::SessionSpecifics* specifics, int64 sync_id) {
+  DCHECK(CalledOnValidThread());
+  NotificationService::current()->Notify(
+      NotificationType::FOREIGN_SESSION_UPDATED,
+      NotificationService::AllSources(),
+      Details<int64>(&sync_id));
+}
+
+bool SessionModelAssociator::AssociateModels() {
+  DCHECK(CalledOnValidThread());
+  UpdateSyncModelDataFromClient();
+  return true;
+}
+
+bool SessionModelAssociator::ChromeModelHasUserCreatedNodes(
+    bool* has_nodes) {
+  DCHECK(CalledOnValidThread());
+  CHECK(has_nodes);
+  // This is wrong, but this function is unused, anyway.
+  *has_nodes = true;
+  return true;
+}
+
+// Sends a notification to ForeignSessionHandler to update the UI, because
+// the session corresponding to the id given has been deleted.
+void SessionModelAssociator::Disassociate(int64 sync_id) {
+  NotificationService::current()->Notify(
+      NotificationType::FOREIGN_SESSION_DELETED,
+      NotificationService::AllSources(),
+      Details<int64>(&sync_id));
+}
+
+const sync_pb::SessionSpecifics* SessionModelAssociator::
+    GetChromeNodeFromSyncId(int64 sync_id) {
+  sync_api::ReadTransaction trans(
+    sync_service_->backend()->GetUserShareHandle());
+  sync_api::ReadNode node(&trans);
+  if (!node.InitByIdLookup(sync_id))
+    return NULL;
+  return new sync_pb::SessionSpecifics(node.GetSessionSpecifics());
+}
+
+bool SessionModelAssociator::GetSyncIdForTaggedNode(const std::string* tag,
+    int64* sync_id) {
+  sync_api::ReadTransaction trans(
+      sync_service_->backend()->GetUserShareHandle());
+  sync_api::ReadNode node(&trans);
+  if (!node.InitByClientTagLookup(syncable::SESSIONS, *tag))
+    return false;
+  *sync_id = node.GetId();
+  return true;
+}
+
+int64 SessionModelAssociator::GetSyncIdFromChromeId(std::string id) {
+  sync_api::ReadTransaction trans(
+      sync_service_->backend()->GetUserShareHandle());
+  sync_api::ReadNode node(&trans);
+  if (!node.InitByClientTagLookup(syncable::SESSIONS, id))
+    return sync_api::kInvalidId;
+  return node.GetId();
+}
+
+bool SessionModelAssociator::SyncModelHasUserCreatedNodes(bool* has_nodes) {
+  DCHECK(CalledOnValidThread());
+  CHECK(has_nodes);
+  *has_nodes = false;
+  sync_api::ReadTransaction trans(
+      sync_service_->backend()->GetUserShareHandle());
+  sync_api::ReadNode root(&trans);
+  if (!root.InitByTagLookup(kSessionsTag)) {
+    LOG(ERROR) << kNoSessionsFolderError;
+    return false;
+  }
+  // The sync model has user created nodes iff the sessions folder has
+  // any children.
+  *has_nodes = root.GetFirstChildId() != sync_api::kInvalidId;
+  return true;
+}
+
+std::string SessionModelAssociator::GetCurrentMachineTag() {
+  if (current_machine_tag_.empty())
+    InitializeCurrentMachineTag();
+  DCHECK(!current_machine_tag_.empty());
+  return current_machine_tag_;
+}
+
+void SessionModelAssociator::AppendForeignSessionFromSpecifics(
+    const sync_pb::SessionSpecifics* specifics,
+    std::vector<ForeignSession*>* session) {
+  ForeignSession* foreign_session = new ForeignSession();
+  foreign_session->foreign_tession_tag = specifics->session_tag();
+  session->insert(session->end(), foreign_session);
+  for (int i = 0; i < specifics->session_window_size(); i++) {
+    const sync_pb::SessionWindow* window = &specifics->session_window(i);
+    SessionWindow* session_window = new SessionWindow();
+    PopulateSessionWindowFromSpecifics(session_window, window);
+    foreign_session->windows.insert(
+        foreign_session->windows.end(), session_window);
+  }
+}
+
+// Fills the given vector with foreign session windows to restore.
+void SessionModelAssociator::AppendForeignSessionWithID(int64 id,
+    std::vector<ForeignSession*>* session, sync_api::BaseTransaction* trans) {
+  if (id == sync_api::kInvalidId)
+    return;
+  sync_api::ReadNode node(trans);
+  if (!node.InitByIdLookup(id))
+    return;
+  const sync_pb::SessionSpecifics* ref = &node.GetSessionSpecifics();
+  AppendForeignSessionFromSpecifics(ref, session);
+}
+
+void SessionModelAssociator::UpdateSyncModelDataFromClient() {
+  DCHECK(CalledOnValidThread());
+  SessionService::SessionCallback* callback =
+      NewCallback(this, &SessionModelAssociator::OnGotSession);
+  // TODO(jerrica): Stop current race condition, possibly make new method in
+  // session service, which only grabs the windows from memory.
+  GetSessionService()->GetCurrentSession(&consumer_, callback);
+}
+
+bool SessionModelAssociator::GetSessionDataFromSyncModel(
+    std::vector<ForeignSession*>* sessions) {
+  std::vector<const sync_pb::SessionSpecifics*> specifics;
+  DCHECK(CalledOnValidThread());
+  sync_api::ReadTransaction trans(
+      sync_service_->backend()->GetUserShareHandle());
+  sync_api::ReadNode root(&trans);
+  if (!root.InitByTagLookup(kSessionsTag)) {
+    LOG(ERROR) << kNoSessionsFolderError;
+    return false;
+  }
+  sync_api::ReadNode current_machine(&trans);
+  int64 current_id = (current_machine.InitByClientTagLookup(syncable::SESSIONS,
+    GetCurrentMachineTag())) ? current_machine.GetId() : sync_api::kInvalidId;
+  // Iterate through the nodes and populate the session model.
+  int64 id = root.GetFirstChildId();
+  while (id != sync_api::kInvalidId) {
+    sync_api::ReadNode sync_node(&trans);
+    if (!sync_node.InitByIdLookup(id)) {
+      LOG(ERROR) << "Failed to fetch sync node for id " << id;
+      return false;
+    }
+    if (id != current_id) {
+      specifics.insert(specifics.end(), &sync_node.GetSessionSpecifics());
+    }
+    id = sync_node.GetSuccessorId();
+  }
+  for (std::vector<const sync_pb::SessionSpecifics*>::const_iterator i =
+    specifics.begin(); i != specifics.end(); ++i) {
+    AppendForeignSessionFromSpecifics(*i, sessions);
+  }
+  return true;
+}
+
+SessionService* SessionModelAssociator::GetSessionService() {
+  DCHECK(sync_service_);
+  Profile* profile = sync_service_->profile();
+  DCHECK(profile);
+  SessionService* sessions_service = profile->GetSessionService();
+  DCHECK(sessions_service);
+  return sessions_service;
+}
+
+void SessionModelAssociator::InitializeCurrentMachineTag() {
+  sync_api::WriteTransaction trans(sync_service_->backend()->
+    GetUserShareHandle());
+  syncable::Directory* dir =
+    trans.GetWrappedWriteTrans()->directory();
+  current_machine_tag_ = "session_sync" + dir->cache_guid();
+}
+
+// See PopulateSessionSpecificsTab for use.  May add functionality that includes
+// the state later.
+void SessionModelAssociator::PopulateSessionSpecificsNavigation(
+  const TabNavigation* navigation, sync_pb::TabNavigation* tab_navigation) {
+  tab_navigation->set_index(navigation->index());
+  tab_navigation->set_virtual_url(navigation->virtual_url().spec());
+  tab_navigation->set_referrer(navigation->referrer().spec());
+  tab_navigation->set_title(UTF16ToUTF8(navigation->title()));
+  switch (navigation->transition()) {
+    case PageTransition::LINK:
+      tab_navigation->set_page_transition(
+        sync_pb::TabNavigation_PageTransition_LINK);
+      break;
+    case PageTransition::TYPED:
+      tab_navigation->set_page_transition(
+        sync_pb::TabNavigation_PageTransition_TYPED);
+      break;
+    case PageTransition::AUTO_BOOKMARK:
+      tab_navigation->set_page_transition(
+        sync_pb::TabNavigation_PageTransition_AUTO_BOOKMARK);
+      break;
+    case PageTransition::AUTO_SUBFRAME:
+      tab_navigation->set_page_transition(
+        sync_pb::TabNavigation_PageTransition_AUTO_SUBFRAME);
+      break;
+    case PageTransition::MANUAL_SUBFRAME:
+      tab_navigation->set_page_transition(
+        sync_pb::TabNavigation_PageTransition_MANUAL_SUBFRAME);
+      break;
+    case PageTransition::GENERATED:
+      tab_navigation->set_page_transition(
+        sync_pb::TabNavigation_PageTransition_GENERATED);
+      break;
+    case PageTransition::START_PAGE:
+      tab_navigation->set_page_transition(
+        sync_pb::TabNavigation_PageTransition_START_PAGE);
+      break;
+    case PageTransition::FORM_SUBMIT:
+      tab_navigation->set_page_transition(
+        sync_pb::TabNavigation_PageTransition_FORM_SUBMIT);
+      break;
+    case PageTransition::RELOAD:
+      tab_navigation->set_page_transition(
+        sync_pb::TabNavigation_PageTransition_RELOAD);
+      break;
+    case PageTransition::KEYWORD:
+      tab_navigation->set_page_transition(
+        sync_pb::TabNavigation_PageTransition_KEYWORD);
+      break;
+    case PageTransition::KEYWORD_GENERATED:
+      tab_navigation->set_page_transition(
+        sync_pb::TabNavigation_PageTransition_KEYWORD_GENERATED);
+      break;
+    case PageTransition::CHAIN_START:
+      tab_navigation->set_page_transition(
+        sync_pb::TabNavigation_PageTransition_CHAIN_START);
+      break;
+    case PageTransition::CHAIN_END:
+      tab_navigation->set_page_transition(
+        sync_pb::TabNavigation_PageTransition_CHAIN_END);
+      break;
+    case PageTransition::CLIENT_REDIRECT:
+      tab_navigation->set_navigation_qualifier(
+        sync_pb::TabNavigation_PageTransitionQualifier_CLIENT_REDIRECT);
+      break;
+    case PageTransition::SERVER_REDIRECT:
+      tab_navigation->set_navigation_qualifier(
+        sync_pb::TabNavigation_PageTransitionQualifier_SERVER_REDIRECT);
+      break;
+    default:
+      tab_navigation->set_page_transition(
+        sync_pb::TabNavigation_PageTransition_TYPED);
+  }
+}
+
+// See PopulateSessionSpecificsWindow for use.
+void SessionModelAssociator::PopulateSessionSpecificsTab(
+  const SessionTab* tab, sync_pb::SessionTab* session_tab) {
+  session_tab->set_tab_visual_index(tab->tab_visual_index);
+  session_tab->set_current_navigation_index(
+      tab->current_navigation_index);
+  session_tab->set_pinned(tab->pinned);
+  session_tab->set_extension_app_id(tab->extension_app_id);
+  for (std::vector<TabNavigation>::const_iterator i3 =
+      tab->navigations.begin(); i3 != tab->navigations.end(); ++i3) {
+    const TabNavigation navigation = *i3;
+    sync_pb::TabNavigation* tab_navigation =
+        session_tab->add_navigation();
+    PopulateSessionSpecificsNavigation(&navigation, tab_navigation);
+  }
+}
+
+// Called when populating session specifics to send to the sync model, called
+// when associating models, or updating the sync model.
+void SessionModelAssociator::PopulateSessionSpecificsWindow(
+  const SessionWindow* window, sync_pb::SessionWindow* session_window) {
+    session_window->set_selected_tab_index(window->selected_tab_index);
+    if (window->type == 1) {
+      session_window->set_browser_type(
+        sync_pb::SessionWindow_BrowserType_TYPE_NORMAL);
+    } else {
+      session_window->set_browser_type(
+        sync_pb::SessionWindow_BrowserType_TYPE_POPUP);
+    }
+    for (std::vector<SessionTab*>::const_iterator i2 = window->tabs.begin();
+        i2 != window->tabs.end(); ++i2) {
+      const SessionTab* tab = *i2;
+      if (tab->navigations.at(tab->current_navigation_index).virtual_url() ==
+        GURL(chrome::kChromeUINewTabURL)) {
+        continue;
+      }
+      sync_pb::SessionTab* session_tab = session_window->add_session_tab();
+      PopulateSessionSpecificsTab(tab, session_tab);
+    }
+}
+
+bool SessionModelAssociator::WindowHasNoTabsToSync(
+    const SessionWindow* window) {
+  int num_populated = 0;
+  for (std::vector<SessionTab*>::const_iterator i = window->tabs.begin();
+      i != window->tabs.end(); ++i) {
+    const SessionTab* tab = *i;
+    if (tab->navigations.at(tab->current_navigation_index).virtual_url() ==
+        GURL(chrome::kChromeUINewTabURL)) {
+      continue;
+    }
+    num_populated++;
+  }
+  if (num_populated == 0)
+    return true;
+  return false;
+}
+
+void SessionModelAssociator::OnGotSession(int handle,
+    std::vector<SessionWindow*>* windows) {
+  sync_pb::SessionSpecifics session;
+  // Set the tag, then iterate through the vector of windows, extracting the
+  // window data, along with the tabs data and tab navigation data to populate
+  // the session specifics.
+  session.set_session_tag(GetCurrentMachineTag());
+  for (std::vector<SessionWindow*>::const_iterator i = windows->begin();
+      i != windows->end(); ++i) {
+    const SessionWindow* window = *i;
+    if (WindowHasNoTabsToSync(window)) {
+       continue;
+    }
+    sync_pb::SessionWindow* session_window = session.add_session_window();
+    PopulateSessionSpecificsWindow(window, session_window);
+  }
+  bool has_nodes = false;
+  if (!SyncModelHasUserCreatedNodes(&has_nodes))
+    return;
+  if (session.session_window_size() == 0 && has_nodes)
+    return;
+  sync_api::WriteTransaction trans(
+      sync_service_->backend()->GetUserShareHandle());
+  sync_api::ReadNode root(&trans);
+  if (!root.InitByTagLookup(kSessionsTag)) {
+    LOG(ERROR) << kNoSessionsFolderError;
+    return;
+  }
+  UpdateSyncModel(&session, &trans, &root);
+}
+
+void SessionModelAssociator::AppendSessionTabNavigation(
+    std::vector<TabNavigation>* navigations,
+    const sync_pb::TabNavigation* navigation) {
+  int index = 0;
+  GURL virtual_url;
+  GURL referrer;
+  string16 title;
+  std::string state;
+  PageTransition::Type transition(PageTransition::LINK);
+  if (navigation->has_index())
+    index = navigation->index();
+  if (navigation->has_virtual_url()) {
+    GURL gurl(navigation->virtual_url());
+    virtual_url = gurl;
+  }
+  if (navigation->has_referrer()) {
+    GURL gurl(navigation->referrer());
+    referrer = gurl;
+  }
+  if (navigation->has_title())
+    title = UTF8ToUTF16(navigation->title());
+  if (navigation->has_page_transition() ||
+      navigation->has_navigation_qualifier()) {
+    switch (navigation->page_transition()) {
+      case sync_pb::TabNavigation_PageTransition_LINK:
+        transition = PageTransition::LINK;
+        break;
+      case sync_pb::TabNavigation_PageTransition_TYPED:
+        transition = PageTransition::TYPED;
+        break;
+      case sync_pb::TabNavigation_PageTransition_AUTO_BOOKMARK:
+        transition = PageTransition::AUTO_BOOKMARK;
+        break;
+      case sync_pb::TabNavigation_PageTransition_AUTO_SUBFRAME:
+        transition = PageTransition::AUTO_SUBFRAME;
+        break;
+      case sync_pb::TabNavigation_PageTransition_MANUAL_SUBFRAME:
+        transition = PageTransition::MANUAL_SUBFRAME;
+        break;
+      case sync_pb::TabNavigation_PageTransition_GENERATED:
+        transition = PageTransition::GENERATED;
+        break;
+      case sync_pb::TabNavigation_PageTransition_START_PAGE:
+        transition = PageTransition::START_PAGE;
+        break;
+      case sync_pb::TabNavigation_PageTransition_FORM_SUBMIT:
+        transition = PageTransition::FORM_SUBMIT;
+        break;
+      case sync_pb::TabNavigation_PageTransition_RELOAD:
+        transition = PageTransition::RELOAD;
+        break;
+      case sync_pb::TabNavigation_PageTransition_KEYWORD:
+        transition = PageTransition::KEYWORD;
+        break;
+      case sync_pb::TabNavigation_PageTransition_KEYWORD_GENERATED:
+        transition = PageTransition::KEYWORD_GENERATED;
+        break;
+      case sync_pb::TabNavigation_PageTransition_CHAIN_START:
+        transition = sync_pb::TabNavigation_PageTransition_CHAIN_START;
+        break;
+      case sync_pb::TabNavigation_PageTransition_CHAIN_END:
+        transition = PageTransition::CHAIN_END;
+        break;
+      default:
+        switch (navigation->navigation_qualifier()) {
+          case sync_pb::
+              TabNavigation_PageTransitionQualifier_CLIENT_REDIRECT:
+            transition = PageTransition::CLIENT_REDIRECT;
+            break;
+            case sync_pb::
+                TabNavigation_PageTransitionQualifier_SERVER_REDIRECT:
+            transition = PageTransition::SERVER_REDIRECT;
+              break;
+            default:
+            transition = PageTransition::TYPED;
+        }
+    }
+  }
+  TabNavigation tab_navigation(index, virtual_url, referrer, title, state,
+                               transition);
+  navigations->insert(navigations->end(), tab_navigation);
+}
+
+void SessionModelAssociator::PopulateSessionTabFromSpecifics(
+    SessionTab* session_tab,
+    const sync_pb::SessionTab* tab, SessionID id) {
+  session_tab->window_id = id;
+  SessionID tabID;
+  session_tab->tab_id = tabID;
+  if (tab->has_tab_visual_index())
+    session_tab->tab_visual_index = tab->tab_visual_index();
+  if (tab->has_current_navigation_index()) {
+    session_tab->current_navigation_index =
+    tab->current_navigation_index();
+  }
+  if (tab->has_pinned())
+    session_tab->pinned = tab->pinned();
+  if (tab->has_extension_app_id())
+    session_tab->extension_app_id = tab->extension_app_id();
+  for (int i3 = 0; i3 < tab->navigation_size(); i3++) {
+    const sync_pb::TabNavigation* navigation = &tab->navigation(i3);
+    AppendSessionTabNavigation(&session_tab->navigations, navigation);
+  }
+}
+
+void SessionModelAssociator::PopulateSessionWindowFromSpecifics(
+    SessionWindow* session_window, const sync_pb::SessionWindow* window) {
+  SessionID id;
+  session_window->window_id = id;
+  if (window->has_selected_tab_index())
+    session_window->selected_tab_index = window->selected_tab_index();
+  if (window->has_browser_type()) {
+    if (window->browser_type() ==
+        sync_pb::SessionWindow_BrowserType_TYPE_NORMAL) {
+      session_window->type = 1;
+    } else {
+      session_window->type = 2;
+    }
+  }
+  for (int i = 0; i < window->session_tab_size(); i++) {
+    const sync_pb::SessionTab& tab = window->session_tab(i);
+    SessionTab* session_tab = new SessionTab();
+    PopulateSessionTabFromSpecifics(session_tab, &tab, id);
+    session_window->tabs.insert(session_window->tabs.end(), session_tab);
+  }
+}
+
+bool SessionModelAssociator::UpdateSyncModel(
+    sync_pb::SessionSpecifics* session_data,
+    sync_api::WriteTransaction* trans,
+    const sync_api::ReadNode* root) {
+  const std::string id = session_data->session_tag();
+  sync_api::WriteNode write_node(trans);
+  if (!write_node.InitByClientTagLookup(syncable::SESSIONS, id)) {
+    sync_api::WriteNode create_node(trans);
+    if (!create_node.InitUniqueByCreation(syncable::SESSIONS, *root, id)) {
+      LOG(ERROR) << "Could not create node for session " << id;
+      return false;
+    }
+    create_node.SetSessionSpecifics(*session_data);
+    return true;
+  }
+  write_node.SetSessionSpecifics(*session_data);
+  return true;
+}
+
+}  // namespace browser_sync
+