NOT FOR COMMIT: Add DeviceInfo type and ChangeProcessor

chrome/browser/sync/profile_sync_service_session_unittest.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
@@ skipping 27 matching lines @@
 #include "google_apis/gaia/gaia_constants.h"
 #include "googleurl/src/gurl.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/change_record.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/protocol/session_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
-#include "sync/test/engine/test_id_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/ui_base_types.h"
 
 using browser_sync::SessionChangeProcessor;
 using browser_sync::SessionDataTypeController;
 using browser_sync::SessionModelAssociator;
 using browser_sync::SyncBackendHost;
 using content::BrowserThread;
 using syncer::ChangeRecord;
 using testing::_;
 using testing::Return;
-using syncer::TestIdFactory;
 
 namespace browser_sync {
 
 namespace {
 
 void BuildSessionSpecifics(const std::string& tag,
                            sync_pb::SessionSpecifics* meta) {
   meta->set_session_tag(tag);
   sync_pb::SessionHeader* header = meta->mutable_header();
-  header->set_device_type(sync_pb::SessionHeader_DeviceType_TYPE_LINUX);
+  header->set_device_type(sync_pb::SyncEnums_DeviceType_TYPE_LINUX);
   header->set_client_name("name");
 }
 
 void AddWindowSpecifics(int window_id,
                         const std::vector<int>& tab_list,
                         sync_pb::SessionSpecifics* meta) {
   sync_pb::SessionHeader* header = meta->mutable_header();
   sync_pb::SessionWindow* window = header->add_window();
   window->set_window_id(window_id);
   window->set_selected_tab_index(0);
   window->set_browser_type(sync_pb::SessionWindow_BrowserType_TYPE_TABBED);
   for (std::vector<int>::const_iterator iter = tab_list.begin();
        iter != tab_list.end(); ++iter) {
     window->add_tab(*iter);
   }
 }
 
 void BuildTabSpecifics(const std::string& tag, int window_id, int tab_id,
-                     sync_pb::SessionSpecifics* tab_base) {
+                       sync_pb::SessionSpecifics* tab_base) {
   tab_base->set_session_tag(tag);
   sync_pb::SessionTab* tab = tab_base->mutable_tab();
   tab->set_tab_id(tab_id);
   tab->set_tab_visual_index(1);
   tab->set_current_navigation_index(0);
   tab->set_pinned(true);
   tab->set_extension_app_id("app_id");
   sync_pb::TabNavigation* navigation = tab->add_navigation();
   navigation->set_virtual_url("http://foo/1");
   navigation->set_referrer("referrer");
@@ skipping 52 matching lines @@
     : public BrowserWithTestWindowTest,
       public content::NotificationObserver {
  public:
   ProfileSyncServiceSessionTest()
       : io_thread_(BrowserThread::IO),
         window_bounds_(0, 1, 2, 3),
         notified_of_update_(false),
         notified_of_refresh_(false) {}
   ProfileSyncService* sync_service() { return sync_service_.get(); }
 
-  TestIdFactory* ids() { return sync_service_->id_factory(); }
-
  protected:
   virtual TestingProfile* CreateProfile() OVERRIDE {
     TestingProfile* profile = new TestingProfile();
     // Don't want the profile to create a real ProfileSyncService.
     ProfileSyncServiceFactory::GetInstance()->SetTestingFactory(profile,
                                                                 NULL);
     return profile;
   }
 
   virtual void SetUp() {
@@ skipping 106 matching lines @@
   }
 
   virtual ~CreateRootHelper() {}
 
   const base::Closure& callback() const { return callback_; }
   bool success() { return success_; }
 
  private:
   void CreateRootCallback(ProfileSyncServiceSessionTest* test) {
     success_ = ProfileSyncServiceTestHelper::CreateRoot(
-        syncer::SESSIONS, test->sync_service()->GetUserShare(), test->ids());
+        syncer::SESSIONS, test->sync_service()->GetUserShare());
   }
 
   base::Closure callback_;
   bool success_;
 };
 
 // Test that we can write this machine's session to a node and retrieve it.
 TEST_F(ProfileSyncServiceSessionTest, WriteSessionToNode) {
   CreateRootHelper create_root(this);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
@@ skipping 893 matching lines @@
     sync_pb::SessionSpecifics specifics;
     header.SetSessionSpecifics(specifics);
   }
   // Ensure we associate properly despite the pre-existing node with our local
   // tag.
   error = model_associator_->AssociateModels();
   ASSERT_FALSE(error.IsSet());
 }
 
 }  // namespace browser_sync