[Sync] Introduce SyncedSessionWindow type.

components/sync_sessions/sessions_sync_manager.cc

 // Copyright 2014 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 "components/sync_sessions/sessions_sync_manager.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "components/sync/base/hash_util.h"
 #include "components/sync/device_info/local_device_info_provider.h"
 #include "components/sync/model/sync_error.h"
 #include "components/sync/model/sync_error_factory.h"
 #include "components/sync/model/sync_merge_result.h"
 #include "components/sync/model/time.h"
 #include "components/sync_sessions/sync_sessions_client.h"
 #include "components/sync_sessions/synced_tab_delegate.h"
 #include "components/sync_sessions/synced_window_delegate.h"
 #include "components/sync_sessions/synced_window_delegates_getter.h"
 #include "components/sync_sessions/tab_node_pool.h"
-#include "components/variations/variations_associated_data.h"
 
 using sessions::SerializedNavigationEntry;
 using syncer::DeviceInfo;
 using syncer::LocalDeviceInfoProvider;
 using syncer::SyncChange;
 using syncer::SyncData;
 
 namespace sync_sessions {
 
 namespace {
@@ skipping 345 matching lines @@
       session_tracker_.GetTab(current_machine_tag(), tab_id);
 
   // Get the previously synced url.
   int old_index = session_tab->normalized_navigation_index();
   GURL old_url;
   if (session_tab->navigations.size() > static_cast<size_t>(old_index))
     old_url = session_tab->navigations[old_index].virtual_url();
 
   // Update the tracker's session representation.
   SetSessionTabFromDelegate(*tab_delegate, base::Time::Now(), session_tab);
-  SetVariationIds(session_tab);
   session_tracker_.GetSession(current_machine_tag())->modified_time =
       base::Time::Now();
 
   // Write to the sync model itself.
   sync_pb::EntitySpecifics specifics;
   specifics.mutable_session()->CopyFrom(
       SessionTabToSpecifics(*session_tab, current_machine_tag(), tab_node_id));
   syncer::SyncData data = syncer::SyncData::CreateLocalData(
       TabNodeIdToTag(current_machine_tag(), tab_node_id), current_session_name_,
       specifics);
@@ skipping 100 matching lines @@
   syncer::SyncDataList list;
   const SyncedSession* session = nullptr;
   if (!session_tracker_.LookupLocalSession(&session))
     return syncer::SyncDataList();
 
   // First construct the header node.
   sync_pb::EntitySpecifics header_entity;
   header_entity.mutable_session()->set_session_tag(current_machine_tag());
   sync_pb::SessionHeader* header_specifics =
       header_entity.mutable_session()->mutable_header();
-  header_specifics->MergeFrom(session->ToSessionHeader());
+  header_specifics->MergeFrom(session->ToSyncSessionHeaderPB());
   syncer::SyncData data = syncer::SyncData::CreateLocalData(
       current_machine_tag(), current_session_name_, header_entity);
   list.push_back(data);
 
   for (auto& win_iter : session->windows) {
-    for (auto& tab : win_iter.second->tabs) {
+    for (auto& tab : win_iter.second->wrapped_window.tabs) {
       // TODO(zea): replace with with the correct tab node id once there's a
       // sync specific wrapper for SessionTab. This method is only used in
       // tests though, so it's fine for now. crbug.com/662597
       int tab_node_id = 0;
       sync_pb::EntitySpecifics entity;
       entity.mutable_session()->CopyFrom(
           SessionTabToSpecifics(*tab, current_machine_tag(), tab_node_id));
       syncer::SyncData data = syncer::SyncData::CreateLocalData(
           TabNodeIdToTag(current_machine_tag(), tab_node_id),
           current_session_name_, entity);
@@ skipping 328 matching lines @@
   }
   session_header->modified_time =
       std::max(mtime, session_header->modified_time);
 }
 
 // static
 void SessionsSyncManager::BuildSyncedSessionFromSpecifics(
     const std::string& session_tag,
     const sync_pb::SessionWindow& specifics,
     base::Time mtime,
-    sessions::SessionWindow* session_window) {
+    SyncedSessionWindow* synced_session_window) {
+  sessions::SessionWindow* session_window =
+      &synced_session_window->wrapped_window;
   if (specifics.has_window_id())
     session_window->window_id.set_id(specifics.window_id());
   if (specifics.has_selected_tab_index())
     session_window->selected_tab_index = specifics.selected_tab_index();
+  synced_session_window->window_type = specifics.browser_type();
   if (specifics.has_browser_type()) {
-    // TODO(skuhne): Sync data writes |BrowserType| not
-    // |SessionWindow::WindowType|. This should get changed.
     if (specifics.browser_type() ==
         sync_pb::SessionWindow_BrowserType_TYPE_TABBED) {
       session_window->type = sessions::SessionWindow::TYPE_TABBED;
     } else {
       // Note: custom tabs are treated like popup windows on restore, as you can
       // restore a custom tab on a platform that doesn't support them.
       session_window->type = sessions::SessionWindow::TYPE_POPUP;
     }
   }
   session_window->timestamp = mtime;
@@ skipping 198 matching lines @@
       session_tab->navigations.push_back(*blocked_navigations[i]);
       session_tab->navigations.back().set_index(offset + i);
       session_tab->navigations.back().set_blocked_state(
           SerializedNavigationEntry::STATE_BLOCKED);
       // TODO(bauerb): Add categories
     }
   }
   session_tab->session_storage_persistent_id.clear();
 }
 
-// static
-void SessionsSyncManager::SetVariationIds(sessions::SessionTab* session_tab) {
-  base::FieldTrial::ActiveGroups active_groups;
-  base::FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
-  for (const base::FieldTrial::ActiveGroup& group : active_groups) {
-    const variations::VariationID id = variations::GetGoogleVariationID(
-        variations::CHROME_SYNC_SERVICE, group.trial_name, group.group_name);
-    if (id != variations::EMPTY_ID)
-      session_tab->variation_ids.push_back(id);
-  }
-}
-
 FaviconCache* SessionsSyncManager::GetFaviconCache() {
   return &favicon_cache_;
 }
 
 SyncedWindowDelegatesGetter*
 SessionsSyncManager::synced_window_delegates_getter() const {
   return sessions_client_->GetSyncedWindowDelegatesGetter();
 }
 
 void SessionsSyncManager::DoGarbageCollection() {
@@ skipping 21 matching lines @@
 }
 
 // static
 std::string SessionsSyncManager::TagHashFromSpecifics(
     const sync_pb::SessionSpecifics& specifics) {
   return syncer::GenerateSyncableHash(syncer::SESSIONS,
                                       TagFromSpecifics(specifics));
 }
 
 };  // namespace sync_sessions