Dynamic updating recent menu for tabs from other devices.

chrome/browser/ui/toolbar/recent_tabs_sub_menu_model_unittest.cc

 // Copyright 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 "chrome/browser/ui/toolbar/recent_tabs_sub_menu_model.h"
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
+#include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/sessions/chrome_tab_restore_service_client.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
+#include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/profile_sync_test_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/sync/browser_synced_window_delegates_getter.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/toolbar/recent_tabs_builder_test_helper.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/browser_with_test_window_test.h"
 #include "chrome/test/base/menu_model_test.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/browser_sync/profile_sync_service_mock.h"
 #include "components/sessions/core/persistent_tab_restore_service.h"
 #include "components/sessions/core/serialized_navigation_entry_test_helper.h"
 #include "components/sessions/core/session_types.h"
 #include "components/sync/base/sync_prefs.h"
 #include "components/sync/device_info/local_device_info_provider_mock.h"
 #include "components/sync/driver/sync_client.h"
 #include "components/sync/model/fake_sync_change_processor.h"
 #include "components/sync/model/sync_error_factory_mock.h"
 #include "components/sync_sessions/sessions_sync_manager.h"
 #include "components/sync_sessions/synced_session.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using testing::_;
+using testing::Invoke;
+using testing::Return;
+
 namespace {
 
 // This copies parts of MenuModelTest::Delegate and combines them with the
 // RecentTabsSubMenuModel since RecentTabsSubMenuModel is a
 // SimpleMenuModel::Delegate and not just derived from SimpleMenuModel.
 class TestRecentTabsSubMenuModel : public RecentTabsSubMenuModel {
  public:
   TestRecentTabsSubMenuModel(ui::AcceleratorProvider* provider,
-                             Browser* browser,
-                             sync_sessions::OpenTabsUIDelegate* delegate)
-      : RecentTabsSubMenuModel(provider, browser, delegate),
+                             Browser* browser)
+      : RecentTabsSubMenuModel(provider, browser),
         execute_count_(0),
         enable_count_(0) {}
 
   // Testing overrides to ui::SimpleMenuModel::Delegate:
   bool IsCommandIdEnabled(int command_id) const override {
     bool val = RecentTabsSubMenuModel::IsCommandIdEnabled(command_id);
     if (val)
       ++enable_count_;
     return val;
   }
@@ skipping 40 matching lines @@
 };
 
 class DummyRouter : public sync_sessions::LocalSessionEventRouter {
  public:
   ~DummyRouter() override {}
   void StartRoutingTo(
       sync_sessions::LocalSessionEventHandler* handler) override {}
   void Stop() override {}
 };
 
+class FakeSyncServiceObserverList {
+ public:
+  FakeSyncServiceObserverList() {}
+  ~FakeSyncServiceObserverList() {}
+
+  void AddObserver(syncer::SyncServiceObserver* observer) {
+    observers_.AddObserver(observer);
+  }
+
+  void RemoveObserver(syncer::SyncServiceObserver* observer) {
+    observers_.RemoveObserver(observer);
+  }
+
+  void NotifyConfigureDone() {
+    for (auto& observer : observers_)
+      observer.OnSyncConfigurationCompleted(nullptr);
+  }
+
+  void NotifyForeignSessionUpdated() {
+    for (auto& observer : observers_)
+      observer.OnForeignSessionUpdated(nullptr);
+  }
+
+ private:
+  base::ObserverList<syncer::SyncServiceObserver, true> observers_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeSyncServiceObserverList);
+};
+
 }  // namespace
 
 class RecentTabsSubMenuModelTest
     : public BrowserWithTestWindowTest {
  public:
-  RecentTabsSubMenuModelTest()
-      : sync_service_(CreateProfileSyncServiceParamsForTest(&testing_profile_)),
-        local_device_(new syncer::LocalDeviceInfoProviderMock(
-            "RecentTabsSubMenuModelTest",
-            "Test Machine",
-            "Chromium 10k",
-            "Chrome 10k",
-            sync_pb::SyncEnums_DeviceType_TYPE_LINUX,
-            "device_id")) {
-    sync_prefs_.reset(new syncer::SyncPrefs(testing_profile_.GetPrefs()));
+  RecentTabsSubMenuModelTest() {}
+
+  void SetUp() override {
+    BrowserWithTestWindowTest::SetUp();
+
+    local_device_ = base::MakeUnique<syncer::LocalDeviceInfoProviderMock>(
+        "RecentTabsSubMenuModelTest", "Test Machine", "Chromium 10k",
+        "Chrome 10k", sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id");
+    sync_prefs_ = base::MakeUnique<syncer::SyncPrefs>(profile()->GetPrefs());
+
+    mock_sync_service_ = static_cast<browser_sync::ProfileSyncServiceMock*>(
+        ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse(
+            profile(), BuildMockProfileSyncService));
+
+    EXPECT_CALL(*mock_sync_service_, AddObserver(_))
+        .WillRepeatedly(Invoke(&fake_sync_service_observer_list_,
+                               &FakeSyncServiceObserverList::AddObserver));
+    EXPECT_CALL(*mock_sync_service_, RemoveObserver(_))
+        .WillRepeatedly(Invoke(&fake_sync_service_observer_list_,
+                               &FakeSyncServiceObserverList::RemoveObserver));
+
     manager_.reset(new sync_sessions::SessionsSyncManager(

[Peter Kasting, 2017/03/24 19:54:02]

Nit: Prefer =MakeUnique to reset(new

-        sync_service_.GetSyncClient()->GetSyncSessionsClient(),
+        mock_sync_service_->GetSyncClient()->GetSyncSessionsClient(),
         sync_prefs_.get(), local_device_.get(),
         std::unique_ptr<sync_sessions::LocalSessionEventRouter>(
             new DummyRouter()),
-        base::Closure(), base::Closure()));
+        base::Bind(&FakeSyncServiceObserverList::NotifyForeignSessionUpdated,
+                   base::Unretained(&fake_sync_service_observer_list_)),
+        base::Closure()));
+
+    DisableSync();

[Peter Kasting, 2017/03/24 19:54:03]

Is this line necessary?

[sath, 2017/03/27 11:29:31]

Okay. I have added DisableSync() or EnabledSync() in each test. 

+
     manager_->MergeDataAndStartSyncing(
         syncer::SESSIONS, syncer::SyncDataList(),
         std::unique_ptr<syncer::SyncChangeProcessor>(
             new syncer::FakeSyncChangeProcessor),
         std::unique_ptr<syncer::SyncErrorFactory>(
             new syncer::SyncErrorFactoryMock));
   }
 
+  void TearDown() override {
+    manager_.reset();
+    sync_prefs_.reset();
+    local_device_.reset();
+    BrowserWithTestWindowTest::TearDown();
+  }
+
   void WaitForLoadFromLastSession() {
     content::RunAllBlockingPoolTasksUntilIdle();
   }
 
+  void DisableSync() {
+    EXPECT_CALL(*mock_sync_service_, IsSyncActive())
+        .WillRepeatedly(Return(false));
+    EXPECT_CALL(*mock_sync_service_, IsDataTypeControllerRunning(_))
+        .WillRepeatedly(Return(false));
+    EXPECT_CALL(*mock_sync_service_, GetOpenTabsUIDelegateMock())
+        .WillRepeatedly(Return(nullptr));
+  }
+
+  void EnableSync() {
+    EXPECT_CALL(*mock_sync_service_, IsSyncActive())
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(*mock_sync_service_,
+                IsDataTypeControllerRunning(syncer::SESSIONS))
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(*mock_sync_service_,
+                IsDataTypeControllerRunning(syncer::PROXY_TABS))
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(*mock_sync_service_, GetOpenTabsUIDelegateMock())
+        .WillRepeatedly(Return(manager_.get()));
+  }
+
+  void NotifySyncEnabled() {
+    fake_sync_service_observer_list_.NotifyConfigureDone();
+  }
+
   static std::unique_ptr<KeyedService> GetTabRestoreService(
       content::BrowserContext* browser_context) {
     return base::MakeUnique<sessions::PersistentTabRestoreService>(
         base::WrapUnique(new ChromeTabRestoreServiceClient(
             Profile::FromBrowserContext(browser_context))),
         nullptr);
   }
 
-  sync_sessions::OpenTabsUIDelegate* GetOpenTabsDelegate() {
-    return manager_.get();
-  }
-
   void RegisterRecentTabs(RecentTabsBuilderTestHelper* helper) {
     helper->ExportToSessionsSyncManager(manager_.get());
   }
 
  private:
-  TestingProfile testing_profile_;
-  browser_sync::ProfileSyncServiceMock sync_service_;
+  std::unique_ptr<syncer::LocalDeviceInfoProviderMock> local_device_;
   std::unique_ptr<syncer::SyncPrefs> sync_prefs_;
+  FakeSyncServiceObserverList fake_sync_service_observer_list_;
+  browser_sync::ProfileSyncServiceMock* mock_sync_service_ = nullptr;
   std::unique_ptr<sync_sessions::SessionsSyncManager> manager_;
-  std::unique_ptr<syncer::LocalDeviceInfoProviderMock> local_device_;
 };
 
 // Test disabled "Recently closed" header with no foreign tabs.
 TEST_F(RecentTabsSubMenuModelTest, NoTabs) {
-  TestRecentTabsSubMenuModel model(NULL, browser(), NULL);
+  TestRecentTabsSubMenuModel model(nullptr, browser());
 
   // Expected menu:
   // Menu index  Menu items
   // ---------------------------------------------
   // 0           History
   // 1           <separator>
   // 2           Recently closed header (disabled)
   // 3           <separator>
   // 4           No tabs from other Devices
 
@@ skipping 21 matching lines @@
 // Test enabled "Recently closed" header with no foreign tabs.
 TEST_F(RecentTabsSubMenuModelTest, RecentlyClosedTabsFromCurrentSession) {
   TabRestoreServiceFactory::GetInstance()->SetTestingFactory(
       profile(), RecentTabsSubMenuModelTest::GetTabRestoreService);
 
   // Add 2 tabs and close them.
   AddTab(browser(), GURL("http://foo/1"));
   AddTab(browser(), GURL("http://foo/2"));
   browser()->tab_strip_model()->CloseAllTabs();
 
-  TestRecentTabsSubMenuModel model(NULL, browser(), NULL);
+  TestRecentTabsSubMenuModel model(nullptr, browser());
   // Expected menu:
   // Menu index  Menu items
   // --------------------------------------
   // 0           History
   // 1           <separator>
   // 2           Recently closed header
   // 3           <tab for http://foo/2>
   // 4           <tab for http://foo/1>
   // 5           <separator>
   // 6           No tabs from other Devices
@@ skipping 73 matching lines @@
   SessionServiceFactory::GetForProfile(profile())->
       MoveCurrentSessionToLastSession();
 
   // Create a new TabRestoreService so that it'll load the recently closed tabs
   // and windows afresh.
   TabRestoreServiceFactory::GetInstance()->SetTestingFactory(
       profile(), RecentTabsSubMenuModelTest::GetTabRestoreService);
   // Let the shutdown of previous TabRestoreService run.
   content::RunAllBlockingPoolTasksUntilIdle();
 
-  TestRecentTabsSubMenuModel model(NULL, browser(), NULL);
+  TestRecentTabsSubMenuModel model(nullptr, browser());
   TestRecentTabsMenuModelDelegate delegate(&model);
   EXPECT_FALSE(delegate.got_changes());
 
   // Expected menu before tabs/windows from last session are loaded:
   // Menu index  Menu items
   // ----------------------------------------------------------------
   // 0           History
   // 1           <separator>
   // 2           Recently closed header
   // 3           <separator>
@@ skipping 61 matching lines @@
   EXPECT_FALSE(model.GetURLAndTitleForItemAtIndex(3, &url, &title));
   EXPECT_TRUE(model.GetURLAndTitleForItemAtIndex(4, &url, &title));
   EXPECT_TRUE(model.GetURLAndTitleForItemAtIndex(5, &url, &title));
   EXPECT_FALSE(model.GetURLAndTitleForItemAtIndex(6, &url, &title));
   EXPECT_FALSE(model.GetURLAndTitleForItemAtIndex(7, &url, &title));
 }
 
 // Test disabled "Recently closed" header with multiple sessions, multiple
 // windows, and multiple enabled tabs from other devices.
 TEST_F(RecentTabsSubMenuModelTest, OtherDevices) {
+  EnableSync();
+
   // Tabs are populated in decreasing timestamp.
   base::Time timestamp = base::Time::Now();
   const base::TimeDelta time_delta = base::TimeDelta::FromMinutes(10);
 
   RecentTabsBuilderTestHelper recent_tabs_builder;
 
   // Create 1st session : 1 window, 3 tabs
   recent_tabs_builder.AddSession();
   recent_tabs_builder.AddWindow(0);
   for (int i = 0; i < 3; ++i) {
@@ skipping 23 matching lines @@
   // 1           <separator>
   // 2           Recently closed header (disabled)
   // 3           <separator>
   // 4           <section header for 1st session>
   // 5-7         <3 tabs of the only window of session 0>
   // 8           <separator>
   // 9           <section header for 2nd session>
   // 10          <the only tab of window 0 of session 1>
   // 11-12       <2 tabs of window 1 of session 2>
 
-  TestRecentTabsSubMenuModel model(NULL, browser(), GetOpenTabsDelegate());
+  TestRecentTabsSubMenuModel model(nullptr, browser());
   int num_items = model.GetItemCount();
   EXPECT_EQ(13, num_items);
   model.ActivatedAt(0);
   EXPECT_TRUE(model.IsEnabledAt(0));
   model.ActivatedAt(1);
   EXPECT_TRUE(model.IsEnabledAt(1));
   model.ActivatedAt(2);
   EXPECT_FALSE(model.IsEnabledAt(2));
   model.ActivatedAt(3);
   EXPECT_TRUE(model.IsEnabledAt(3));
@@ skipping 37 matching lines @@
   EXPECT_TRUE(model.GetURLAndTitleForItemAtIndex(5, &url, &title));
   EXPECT_TRUE(model.GetURLAndTitleForItemAtIndex(6, &url, &title));
   EXPECT_TRUE(model.GetURLAndTitleForItemAtIndex(7, &url, &title));
   EXPECT_FALSE(model.GetURLAndTitleForItemAtIndex(8, &url, &title));
   EXPECT_FALSE(model.GetURLAndTitleForItemAtIndex(9, &url, &title));
   EXPECT_TRUE(model.GetURLAndTitleForItemAtIndex(10, &url, &title));
   EXPECT_TRUE(model.GetURLAndTitleForItemAtIndex(11, &url, &title));
   EXPECT_TRUE(model.GetURLAndTitleForItemAtIndex(12, &url, &title));
 }
 
-// Per http://crbug.com/603744, MaxSessionsAndRecenty fails intermittently on
-// windows, linux and mac.
-#if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_MACOSX)
-#define MAYBE_MaxSessionsAndRecency DISABLED_MaxSessionsAndRecency
+// Mac doesn't support the dynamic menu.
+#if defined(OS_MACOSX)
+#define MAYBE_OtherDevicesDynamicUpdate DISABLED_OtherDevicesDynamicUpdate
 #else
-#define MAYBE_MaxSessionsAndRecency MaxSessionsAndRecency
+#define MAYBE_OtherDevicesDynamicUpdate OtherDevicesDynamicUpdate
 #endif
-TEST_F(RecentTabsSubMenuModelTest, MAYBE_MaxSessionsAndRecency) {
+TEST_F(RecentTabsSubMenuModelTest, OtherDevicesDynamicUpdate) {
+  // Create menu with disabled syncronization.

[Peter Kasting, 2017/03/24 19:54:02]

Nit: synchronization

+  DisableSync();
+
+  // Before creating menu fill foreign sessions.
+  base::Time update_timestamp =
+      base::Time::Now() - base::TimeDelta::FromMinutes(10);
+
+  RecentTabsBuilderTestHelper recent_tabs_builder;
+
+  // Create one session with one window and one tab.
+  recent_tabs_builder.AddSession();
+  recent_tabs_builder.AddWindow(0);
+  recent_tabs_builder.AddTabWithInfo(0, 0, update_timestamp, base::string16());
+
+  RegisterRecentTabs(&recent_tabs_builder);
+
+  // Verify that data is populated correctly in RecentTabsSubMenuModel.
+  // Expected menu:
+  // Menu index  Menu items
+  // -----------------------------------------------------
+  // 0           History
+  // 1           <separator>
+  // 2           Recently closed header (disabled)
+  // 3           <separator>
+  // 4           No tabs from other Devices
+
+  TestRecentTabsSubMenuModel model(nullptr, browser());
+  EXPECT_EQ(5, model.GetItemCount());
+  model.ActivatedAt(4);
+  EXPECT_FALSE(model.IsEnabledAt(4));
+
+  EXPECT_EQ(0, model.enable_count());
+  EXPECT_EQ(1, model.execute_count());
+
+  EXPECT_EQ(nullptr, model.GetLabelFontListAt(4));
+
+  std::string url;
+  base::string16 title;
+  EXPECT_FALSE(model.GetURLAndTitleForItemAtIndex(4, &url, &title));
+
+  // Enable syncronization and notify menu that syncronization was enabled.
+  int previous_enable_count = model.enable_count();
+  int previous_execute_count = model.execute_count();
+
+  EnableSync();
+  NotifySyncEnabled();
+
+  // Verify that data is populated correctly in RecentTabsSubMenuModel.
+  // Expected menu:
+  // Menu index  Menu items
+  // -----------------------------------------------------
+  // 0           History
+  // 1           <separator>
+  // 2           Recently closed header (disabled)
+  // 3           <separator>
+  // 4           <section header for 1st session>
+  // 5           <tab of the only window of session 0>
+
+  EXPECT_EQ(6, model.GetItemCount());
+  model.ActivatedAt(4);
+  EXPECT_FALSE(model.IsEnabledAt(4));
+  model.ActivatedAt(5);
+  EXPECT_TRUE(model.IsEnabledAt(5));
+
+  EXPECT_EQ(previous_enable_count + 1, model.enable_count());
+  EXPECT_EQ(previous_execute_count + 2, model.execute_count());
+
+  EXPECT_NE(nullptr, model.GetLabelFontListAt(4));
+  EXPECT_EQ(nullptr, model.GetLabelFontListAt(5));
+
+  EXPECT_FALSE(model.GetURLAndTitleForItemAtIndex(4, &url, &title));
+  EXPECT_TRUE(model.GetURLAndTitleForItemAtIndex(5, &url, &title));
+
+  // Make changes dynamically.
+  previous_enable_count = model.enable_count();
+  previous_execute_count = model.execute_count();
+
+  update_timestamp = base::Time::Now() - base::TimeDelta::FromMinutes(5);
+
+  // Add tab to the only window.
+  recent_tabs_builder.AddTabWithInfo(0, 0, update_timestamp, base::string16());
+
+  RegisterRecentTabs(&recent_tabs_builder);
+
+  // Verify that data is populated correctly in RecentTabsSubMenuModel.
+  // Expected menu:
+  // Menu index  Menu items
+  // -----------------------------------------------------
+  // 0           History
+  // 1           <separator>
+  // 2           Recently closed header (disabled)
+  // 3           <separator>
+  // 4           <section header for 1st session>
+  // 5           <new added tab of the only window of session 0>
+  // 6           <tab of the only window of session 0>
+
+  EXPECT_EQ(7, model.GetItemCount());
+  model.ActivatedAt(4);
+  EXPECT_FALSE(model.IsEnabledAt(4));
+  model.ActivatedAt(5);
+  EXPECT_TRUE(model.IsEnabledAt(5));
+  model.ActivatedAt(6);
+  EXPECT_TRUE(model.IsEnabledAt(6));
+
+  EXPECT_EQ(previous_enable_count + 2, model.enable_count());
+  EXPECT_EQ(previous_execute_count + 3, model.execute_count());
+
+  EXPECT_NE(nullptr, model.GetLabelFontListAt(4));
+  EXPECT_EQ(nullptr, model.GetLabelFontListAt(5));
+  EXPECT_EQ(nullptr, model.GetLabelFontListAt(6));
+
+  EXPECT_FALSE(model.GetURLAndTitleForItemAtIndex(4, &url, &title));
+  EXPECT_TRUE(model.GetURLAndTitleForItemAtIndex(5, &url, &title));
+  EXPECT_TRUE(model.GetURLAndTitleForItemAtIndex(6, &url, &title));
+}
+
+TEST_F(RecentTabsSubMenuModelTest, MaxSessionsAndRecency) {
+  EnableSync();
+
   // Create 4 sessions : each session has 1 window with 1 tab each.
   RecentTabsBuilderTestHelper recent_tabs_builder;
   for (int s = 0; s < 4; ++s) {
     recent_tabs_builder.AddSession();
     recent_tabs_builder.AddWindow(s);
     recent_tabs_builder.AddTab(s, 0);
   }
   RegisterRecentTabs(&recent_tabs_builder);
 
   // Verify that data is populated correctly in RecentTabsSubMenuModel.
   // Expected menu:
   // - max sessions is 3, so only 3 most-recent sessions will show.
   // Menu index  Menu items
   // ----------------------------------------------------------
   // 0           History
   // 1           <separator>
   // 2           Recently closed header (disabled)
   // 3           <separator>
   // 4           <section header for 1st session>
   // 5           <the only tab of the only window of session 3>
   // 6           <separator>
   // 7           <section header for 2nd session>
   // 8           <the only tab of the only window of session 2>
   // 9           <separator>
   // 10          <section header for 3rd session>
   // 11          <the only tab of the only window of session 1>
 
-  TestRecentTabsSubMenuModel model(NULL, browser(), GetOpenTabsDelegate());
+  TestRecentTabsSubMenuModel model(nullptr, browser());
   int num_items = model.GetItemCount();
   EXPECT_EQ(12, num_items);
 
   std::vector<base::string16> tab_titles =
       recent_tabs_builder.GetTabTitlesSortedByRecency();
   EXPECT_EQ(tab_titles[0], model.GetLabelAt(5));
   EXPECT_EQ(tab_titles[1], model.GetLabelAt(8));
   EXPECT_EQ(tab_titles[2], model.GetLabelAt(11));
 }
 
 TEST_F(RecentTabsSubMenuModelTest, MaxTabsPerSessionAndRecency) {
+  EnableSync();
+
   // Create a session: 2 windows with 5 tabs each.
   RecentTabsBuilderTestHelper recent_tabs_builder;
   recent_tabs_builder.AddSession();
   for (int w = 0; w < 2; ++w) {
     recent_tabs_builder.AddWindow(0);
     for (int t = 0; t < 5; ++t)
       recent_tabs_builder.AddTab(0, w);
   }
   RegisterRecentTabs(&recent_tabs_builder);
 
   // Verify that data is populated correctly in RecentTabsSubMenuModel.
   // Expected menu:
   // - max tabs per session is 4, so only 4 most-recent tabs will show,
   //   independent of which window they came from.
   // Menu index  Menu items
   // ---------------------------------------------
   // 0           History
   // 1           <separator>
   // 2           Recently closed header (disabled)
   // 3           <separator>
   // 4           <section header for session>
   // 5-8         <4 most-recent tabs of session>
 
-  TestRecentTabsSubMenuModel model(NULL, browser(), GetOpenTabsDelegate());
+  TestRecentTabsSubMenuModel model(nullptr, browser());
   int num_items = model.GetItemCount();
   EXPECT_EQ(9, num_items);
 
   std::vector<base::string16> tab_titles =
       recent_tabs_builder.GetTabTitlesSortedByRecency();
   for (int i = 0; i < 4; ++i)
     EXPECT_EQ(tab_titles[i], model.GetLabelAt(i + 5));
 }
 
 TEST_F(RecentTabsSubMenuModelTest, MaxWidth) {
+  EnableSync();
+
   // Create 1 session with 1 window and 1 tab.
   RecentTabsBuilderTestHelper recent_tabs_builder;
   recent_tabs_builder.AddSession();
   recent_tabs_builder.AddWindow(0);
   recent_tabs_builder.AddTab(0, 0);
   RegisterRecentTabs(&recent_tabs_builder);
 
   // Menu index  Menu items
   // ----------------------------------------------------------
   // 0           History
   // 1           <separator>
   // 2           Recently closed header (disabled)
   // 3           <separator>
   // 4           <section header for 1st session>
   // 5           <the only tab of the only window of session 1>
 
-  TestRecentTabsSubMenuModel model(NULL, browser(), GetOpenTabsDelegate());
+  TestRecentTabsSubMenuModel model(nullptr, browser());
   EXPECT_EQ(6, model.GetItemCount());
   EXPECT_EQ(-1, model.GetMaxWidthForItemAtIndex(2));
   EXPECT_NE(-1, model.GetMaxWidthForItemAtIndex(3));
   EXPECT_NE(-1, model.GetMaxWidthForItemAtIndex(4));
   EXPECT_NE(-1, model.GetMaxWidthForItemAtIndex(5));
 }
 
 TEST_F(RecentTabsSubMenuModelTest, MaxWidthNoDevices) {
   // Expected menu:
   // Menu index  Menu items
   // --------------------------------------------
   // 0           History
   // 1           <separator>
   // 2           Recently closed heaer (disabled)
   // 3           <separator>
   // 4           No tabs from other Devices
 
-  TestRecentTabsSubMenuModel model(NULL, browser(), NULL);
+  TestRecentTabsSubMenuModel model(nullptr, browser());
   EXPECT_EQ(5, model.GetItemCount());
   EXPECT_EQ(-1, model.GetMaxWidthForItemAtIndex(2));
   EXPECT_NE(-1, model.GetMaxWidthForItemAtIndex(3));
   EXPECT_EQ(-1, model.GetMaxWidthForItemAtIndex(4));
 }