Add the fieldtrial testing config for InfiniteSessionRestore

Bug: 863441
Change-Id: Ida53af27cb6d43f5b750a80cdbfe82582e9548a9
Reviewed-on: https://chromium-review.googlesource.com/1161187
Commit-Queue: Sébastien Marchand <sebmarchand@chromium.org>
Reviewed-by: Chris Hamilton <chrisha@chromium.org>
Reviewed-by: Steven Holte <holte@chromium.org>
Cr-Commit-Position: refs/heads/master@{#583872}

chrome/browser/resource_coordinator/session_restore_policy.h

@@ -32,7 +32,9 @@ class SessionRestorePolicy {
   // session restore. If this returns false then session restore should mark the
   // tab load as deferred and move onto the next tab to restore. Note that this
   // always returns true if the policy logic is disabled.
-  bool ShouldLoad(content::WebContents* contents) const;
+  //
+  // Virtual for testing.
+  virtual bool ShouldLoad(content::WebContents* contents) const;
 
   // Intended to be called by the policy client whenever a tab load has been
   // initiated.

chrome/browser/sessions/session_restore_browsertest.cc

@@ -24,11 +24,13 @@
 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
-#include "chrome/browser/sessions/session_restore.h"
+#include "chrome/browser/resource_coordinator/session_restore_policy.h"
+#include "chrome/browser/resource_coordinator/tab_manager_features.h"
 #include "chrome/browser/sessions/session_restore_test_helper.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sessions/session_service_test_helper.h"
+#include "chrome/browser/sessions/tab_loader_delegate.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
@@ -207,11 +209,33 @@ class SessionRestoreTest : public InProcessBrowserTest {
   const BrowserList* active_browser_list_;
 };
 
+// SessionRestorePolicy that always allow tabs to load.
+class TestSessionRestorePolicy
+    : public resource_coordinator::SessionRestorePolicy {
+ public:
+  // Always allow tabs to load so we can test the behavior of SessionRestore
+  // independently from the policy logic.
+  bool ShouldLoad(content::WebContents* contents) const override {
+    return true;
+  }
+};
+
 // Activates the smart restore behaviour and tracks the loading of tabs.
 class SmartSessionRestoreTest : public SessionRestoreTest,
                                       public content::NotificationObserver {
  public:
   SmartSessionRestoreTest() {}
+
+  void SetUp() override {
+    TabLoaderDelegate::SetSessionRestorePolicyForTesting(&test_policy_);
+    SessionRestoreTest::SetUp();
+  }
+
+  void TearDown() override {
+    TabLoaderDelegate::SetSessionRestorePolicyForTesting(nullptr);
+    SessionRestoreTest::TearDown();
+  }
+
   void StartObserving(size_t num_tabs) {
     // Start by clearing everything so it can be reused in the same test.
     web_contents_.clear();
@@ -253,6 +277,7 @@ class SmartSessionRestoreTest : public SessionRestoreTest,
   std::vector<content::WebContents*> web_contents_;
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
   size_t num_tabs_;
+  TestSessionRestorePolicy test_policy_;
 
   DISALLOW_COPY_AND_ASSIGN(SmartSessionRestoreTest);
 };

chrome/browser/sessions/tab_loader_delegate.cc

@@ -28,6 +28,8 @@ static const int kInitialDelayTimerMS = 1500;
 // first paint and interactivity of the foreground tab.
 static const int kFirstTabLoadTimeoutMS = 60000;
 
+resource_coordinator::SessionRestorePolicy* g_testing_policy = nullptr;
+
 class TabLoaderDelegateImpl
     : public TabLoaderDelegate,
       public network::NetworkConnectionTracker::NetworkConnectionObserver {
@@ -47,23 +49,28 @@ class TabLoaderDelegateImpl
 
   // TabLoaderDelegate:
   size_t GetMaxSimultaneousTabLoads() const override {
-    return policy_.simultaneous_tab_loads();
+    return policy_->simultaneous_tab_loads();
   }
 
   // TabLoaderDelegate:
   bool ShouldLoad(content::WebContents* contents) const override {
-    return policy_.ShouldLoad(contents);
+    return policy_->ShouldLoad(contents);
   }
 
   // TabLoaderDelegate:
-  void NotifyTabLoadStarted() override { policy_.NotifyTabLoadStarted(); }
+  void NotifyTabLoadStarted() override { policy_->NotifyTabLoadStarted(); }
 
   // network::NetworkConnectionTracker::NetworkConnectionObserver:
   void OnConnectionChanged(network::mojom::ConnectionType type) override;
 
  private:
-  // The policy engine used to implement ShouldLoad.
-  resource_coordinator::SessionRestorePolicy policy_;
+  // The default policy engine used to implement ShouldLoad.
+  resource_coordinator::SessionRestorePolicy default_policy_;
+
+  // The policy engine used to implement ShouldLoad. By default this is simply
+  // a pointer to |default_policy_|, but it can also point to externally
+  // injected policy engine for testing.
+  resource_coordinator::SessionRestorePolicy* policy_;
 
   // The function to call when the connection type changes.
   TabLoaderCallback* callback_;
@@ -78,7 +85,7 @@ class TabLoaderDelegateImpl
 };
 
 TabLoaderDelegateImpl::TabLoaderDelegateImpl(TabLoaderCallback* callback)
-    : callback_(callback), weak_factory_(this) {
+    : policy_(&default_policy_), callback_(callback), weak_factory_(this) {
   content::GetNetworkConnectionTracker()->AddNetworkConnectionObserver(this);
   auto type = network::mojom::ConnectionType::CONNECTION_UNKNOWN;
   content::GetNetworkConnectionTracker()->GetConnectionType(
@@ -94,6 +101,11 @@ TabLoaderDelegateImpl::TabLoaderDelegateImpl(TabLoaderCallback* callback)
 
   first_timeout_ = base::TimeDelta::FromMilliseconds(kFirstTabLoadTimeoutMS);
   timeout_ = base::TimeDelta::FromMilliseconds(kInitialDelayTimerMS);
+
+  // Override |policy_| if a testing policy has been set.
+  if (g_testing_policy) {
+    policy_ = g_testing_policy;
+  }
 }
 
 TabLoaderDelegateImpl::~TabLoaderDelegateImpl() {
@@ -114,3 +126,9 @@ std::unique_ptr<TabLoaderDelegate> TabLoaderDelegate::Create(
   return std::unique_ptr<TabLoaderDelegate>(
       new TabLoaderDelegateImpl(callback));
 }
+
+// static
+void TabLoaderDelegate::SetSessionRestorePolicyForTesting(
+    resource_coordinator::SessionRestorePolicy* policy) {
+  g_testing_policy = policy;
+}

chrome/browser/sessions/tab_loader_delegate.h

@@ -13,6 +13,10 @@ namespace content {
 class WebContents;
 }
 
+namespace resource_coordinator {
+class SessionRestorePolicy;
+}
+
 class TabLoaderCallback {
  public:
   // This function will get called to suppress and to allow tab loading. Tab
@@ -52,6 +56,10 @@ class TabLoaderDelegate {
   // Notifies the delegate that a tab load has been initiated.
   virtual void NotifyTabLoadStarted() = 0;
 
+  // Testing seam to inject a custom SessionRestorePolicy.
+  static void SetSessionRestorePolicyForTesting(
+      resource_coordinator::SessionRestorePolicy* policy);
+
  protected:
   // The delegate should only be created via the factory function.
   TabLoaderDelegate() {}

testing/variations/fieldtrial_testing_config.json

@@ -2026,6 +2026,24 @@
             ]
         }
     ],
+    "InfiniteSessionRestore": [
+        {
+            "platforms": [
+                "chromeos",
+                "linux",
+                "mac",
+                "windows"
+            ],
+            "experiments": [
+                {
+                    "name": "Enabled",
+                    "enable_features": [
+                        "InfiniteSessionRestore"
+                    ]
+                }
+            ]
+        }
+    ],
     "InspectDownloadedRarFiles": [
         {
             "platforms": [