Do not submit: high level overview patch.

chrome/browser/sync/glue/session_model_associator_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 <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "chrome/browser/sessions/session_types.h"
@@ skipping 13 matching lines @@
 #include "sync/protocol/session_specifics.pb.h"
 #include "sync/util/time.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 using sessions::SerializedNavigationEntry;
 using sessions::SerializedNavigationEntryTestHelper;
 using testing::NiceMock;
 using testing::Return;
+using testing::ReturnRef;
 using testing::StrictMock;
 using testing::_;
 
 namespace browser_sync {
 
 class SyncSessionModelAssociatorTest : public testing::Test {
  protected:
   SyncSessionModelAssociatorTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         sync_service_(&profile_),
@@ skipping 123 matching lines @@
   ASSERT_EQ(1U, tracker.num_synced_tabs(std::string("tag")));
 }
 
 namespace {
 
 class SyncedTabDelegateMock : public SyncedTabDelegate {
  public:
   SyncedTabDelegateMock() {}
   virtual ~SyncedTabDelegateMock() {}
 
-  MOCK_CONST_METHOD0(GetWindowId, SessionID::id_type());
-  MOCK_CONST_METHOD0(GetSessionId, SessionID::id_type());
+  MOCK_CONST_METHOD0(GetWindowId, const SessionID&());
+  MOCK_CONST_METHOD0(GetSessionId, const SessionID&());
   MOCK_CONST_METHOD0(IsBeingDestroyed, bool());
   MOCK_CONST_METHOD0(profile, Profile*());
   MOCK_CONST_METHOD0(GetExtensionAppId, std::string());
   MOCK_CONST_METHOD0(GetCurrentEntryIndex, int());
   MOCK_CONST_METHOD0(GetEntryCount, int());
   MOCK_CONST_METHOD0(GetPendingEntryIndex, int());
   MOCK_CONST_METHOD0(GetPendingEntry, content::NavigationEntry*());
   MOCK_CONST_METHOD1(GetEntryAtIndex, content::NavigationEntry*(int i));
   MOCK_CONST_METHOD0(GetActiveEntry, content::NavigationEntry*());
   MOCK_CONST_METHOD0(IsPinned, bool());
+  MOCK_CONST_METHOD0(GetSyncSessionId, int64());
+  MOCK_CONST_METHOD0(IsTabInMemory, bool());
+  MOCK_METHOD1(SetSyncSessionId, void(const int64));
+
 };
 
 class SyncRefreshListener : public content::NotificationObserver {
  public:
   SyncRefreshListener() : notified_of_refresh_(false) {
     registrar_.Add(this, chrome::NOTIFICATION_SYNC_REFRESH_LOCAL,
         content::NotificationService::AllSources());
   }
 
   virtual void Observe(int type,
@@ skipping 20 matching lines @@
   model_associator_.AttemptSessionsDataRefresh();
   EXPECT_TRUE(refresh_listener.notified_of_refresh());
 }
 
 // Test that we exclude tabs with only chrome:// and file:// schemed navigations
 // from ShouldSyncTab(..).
 TEST_F(SyncSessionModelAssociatorTest, ValidTabs) {
   NiceMock<SyncedTabDelegateMock> tab_mock;
 
   // A null entry shouldn't crash.
+  SessionID window_id;
+  ON_CALL(tab_mock, GetWindowId()).WillByDefault(ReturnRef(window_id));
   EXPECT_CALL(tab_mock, GetCurrentEntryIndex()).WillRepeatedly(Return(0));
   EXPECT_CALL(tab_mock, GetEntryAtIndex(0)).WillRepeatedly(
       Return((content::NavigationEntry *)NULL));
   EXPECT_CALL(tab_mock, GetEntryCount()).WillRepeatedly(Return(1));
   EXPECT_CALL(tab_mock, GetPendingEntryIndex()).WillRepeatedly(Return(-1));
   EXPECT_FALSE(model_associator_.ShouldSyncTab(tab_mock));
 
   // A chrome:// entry isn't valid.
   scoped_ptr<content::NavigationEntry> entry(
       content::NavigationEntry::Create());
@@ skipping 68 matching lines @@
 const base::Time kTime3 = base::Time::FromInternalValue(110);
 const base::Time kTime4 = base::Time::FromInternalValue(120);
 const base::Time kTime5 = base::Time::FromInternalValue(130);
 
 // Populate the mock tab delegate with some data and navigation
 // entries and make sure that setting a SessionTab from it preserves
 // those entries (and clobbers any existing data).
 TEST_F(SyncSessionModelAssociatorTest, SetSessionTabFromDelegate) {
   // Create a tab with three valid entries.
   NiceMock<SyncedTabDelegateMock> tab_mock;
-  EXPECT_CALL(tab_mock, GetSessionId()).WillRepeatedly(Return(0));
+  SessionID window_id;
+  ON_CALL(tab_mock, GetWindowId()).WillByDefault(ReturnRef(window_id));
+  SessionID tab_id;
+  EXPECT_CALL(tab_mock, GetSessionId()).WillRepeatedly(ReturnRef(tab_id));
   scoped_ptr<content::NavigationEntry> entry1(
       content::NavigationEntry::Create());
   entry1->SetVirtualURL(GURL("http://www.google.com"));
   entry1->SetTimestamp(kTime1);
   scoped_ptr<content::NavigationEntry> entry2(
       content::NavigationEntry::Create());
   entry2->SetVirtualURL(GURL("http://www.noodle.com"));
   entry2->SetTimestamp(kTime2);
   scoped_ptr<content::NavigationEntry> entry3(
       content::NavigationEntry::Create());
@@ skipping 17 matching lines @@
   session_tab.pinned = true;
   session_tab.extension_app_id = "app id";
   session_tab.user_agent_override = "override";
   session_tab.timestamp = kTime5;
   session_tab.navigations.push_back(
       SerializedNavigationEntryTestHelper::CreateNavigation(
           "http://www.example.com", "Example"));
   session_tab.session_storage_persistent_id = "persistent id";
   SetSessionTabFromDelegate(tab_mock, kTime4, &session_tab);
 
-  EXPECT_EQ(0, session_tab.window_id.id());
-  EXPECT_EQ(0, session_tab.tab_id.id());
+  EXPECT_EQ(window_id.id(), session_tab.window_id.id());
+  EXPECT_EQ(tab_id.id(), session_tab.tab_id.id());
   EXPECT_EQ(0, session_tab.tab_visual_index);
   EXPECT_EQ(2, session_tab.current_navigation_index);
   EXPECT_FALSE(session_tab.pinned);
   EXPECT_TRUE(session_tab.extension_app_id.empty());
   EXPECT_TRUE(session_tab.user_agent_override.empty());
   EXPECT_EQ(kTime4, session_tab.timestamp);
   ASSERT_EQ(3u, session_tab.navigations.size());
   EXPECT_EQ(entry1->GetVirtualURL(),
             session_tab.navigations[0].virtual_url());
   EXPECT_EQ(entry2->GetVirtualURL(),
@@ skipping 98 matching lines @@
   // The new page should be mapped to the old favicon data.
   EXPECT_TRUE(FaviconEquals(GURL(page_url2), std::string()));
   LoadTabFavicon(tab2);
   EXPECT_TRUE(FaviconEquals(GURL(page_url), favicon));
   EXPECT_TRUE(FaviconEquals(GURL(page_url2), favicon));
 }
 
 }  // namespace
 
 }  // namespace browser_sync