Use TabLoader in TabRestoreService.

chrome/browser/sessions/tab_loader.cc

 // Copyright 2015 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/sessions/tab_loader.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/memory/memory_coordinator_client_registry.h"
@@ skipping 13 matching lines @@
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_features.h"
 
 using content::NavigationController;
 using content::RenderWidgetHost;
 using content::WebContents;
 
+namespace {
+
+size_t g_max_loaded_tab_count_for_testing = 0;
+
+}  // namespace
+
 void TabLoader::Observe(int type,
                         const content::NotificationSource& source,
                         const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_WEB_CONTENTS_DESTROYED: {
       WebContents* web_contents = content::Source<WebContents>(source).ptr();
       HandleTabClosedOrLoaded(&web_contents->GetController());
       break;
     }
     case content::NOTIFICATION_LOAD_STOP: {
@@ skipping 27 matching lines @@
 // static
 void TabLoader::RestoreTabs(const std::vector<RestoredTab>& tabs,
                             const base::TimeTicks& restore_started) {
   if (!shared_tab_loader_)
     shared_tab_loader_ = new TabLoader(restore_started);
 
   shared_tab_loader_->stats_collector_->TrackTabs(tabs);
   shared_tab_loader_->StartLoading(tabs);
 }
 
+// static
+void TabLoader::SetMaxLoadedTabCountForTest(size_t value) {
+  g_max_loaded_tab_count_for_testing = value;
+}
+
 TabLoader::TabLoader(base::TimeTicks restore_started)
     : memory_pressure_listener_(
           base::Bind(&TabLoader::OnMemoryPressure, base::Unretained(this))),
       force_load_delay_multiplier_(1),
       loading_enabled_(true),
+      started_to_load_count_(0),
       restore_started_(restore_started) {
   stats_collector_ = new SessionRestoreStatsCollector(
       restore_started,
       base::MakeUnique<
           SessionRestoreStatsCollector::UmaStatsReportingDelegate>());
   shared_tab_loader_ = this;
   this_retainer_ = this;
   base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this);
 }
 
@@ skipping 15 matching lines @@
   for (auto& restored_tab : tabs) {
     if (!restored_tab.is_active()) {
       tabs_to_load_.push_back(&restored_tab.contents()->GetController());
       favicon::ContentFaviconDriver* favicon_driver =
           favicon::ContentFaviconDriver::FromWebContents(
               restored_tab.contents());
       // |favicon_driver| might be null when testing.
       if (favicon_driver)
         favicon_driver->FetchFavicon(favicon_driver->GetActiveURL());
     } else {
+      ++started_to_load_count_;
       tabs_loading_.insert(&restored_tab.contents()->GetController());
     }
     RegisterForNotifications(&restored_tab.contents()->GetController());
   }
 
   // When multiple profiles are using the same TabLoader, another profile might
   // already have started loading. In that case, the tabs scheduled for loading
   // by this profile are already in the loading queue, and they will get loaded
   // eventually.
   if (delegate_)
@@ skipping 30 matching lines @@
     // large delay between a memory pressure event and receiving a notification
     // of that event (in that case tab restore can trigger memory pressure but
     // will complete before the notification arrives).
     if (ShouldStopLoadingTabs()) {
       StopLoadingTabs();
       return;
     }
 
     NavigationController* controller = tabs_to_load_.front();
     DCHECK(controller);
+    ++started_to_load_count_;
     tabs_loading_.insert(controller);
     tabs_to_load_.pop_front();
     controller->LoadIfNecessary();
     content::WebContents* contents = controller->GetWebContents();
     if (contents) {
       Browser* browser = chrome::FindBrowserWithWebContents(contents);
       if (browser &&
           browser->tab_strip_model()->GetActiveWebContents() != contents) {
         // By default tabs are marked as visible. As only the active tab is
         // visible we need to explicitly tell non-active tabs they are hidden.
@@ skipping 54 matching lines @@
                  content::Source<NavigationController>(controller));
 }
 
 void TabLoader::HandleTabClosedOrLoaded(NavigationController* controller) {
   RemoveTab(controller);
   if (delegate_)
     LoadNextTab();
 }
 
 bool TabLoader::ShouldStopLoadingTabs() const {
+  if (g_max_loaded_tab_count_for_testing != 0 &&
+      started_to_load_count_ >= g_max_loaded_tab_count_for_testing)
+    return true;
   if (base::FeatureList::IsEnabled(features::kMemoryCoordinator))
     return base::MemoryCoordinatorProxy::GetInstance()->GetCurrentMemoryState()
         != base::MemoryState::NORMAL;
   if (base::MemoryPressureMonitor::Get()) {
     return base::MemoryPressureMonitor::Get()->GetCurrentPressureLevel() !=
         base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
   }
   return false;
 }
 
@@ skipping 36 matching lines @@
     // memory pressure.
     stats_collector_->DeferTab(tab);
   }
   // By calling |LoadNextTab| explicitly, we make sure that the
   // |NOTIFICATION_SESSION_RESTORE_DONE| event gets sent.
   LoadNextTab();
 }
 
 // static
 TabLoader* TabLoader::shared_tab_loader_ = nullptr;