Make session restore forced tab load delay Finch configurable, and separate first tab loads from su…

chrome/browser/sessions/tab_loader_delegate.cc

 // Copyright 2014 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_delegate.h"
 
+#include "base/strings/string_number_conversions.h"
+#include "components/variations/variations_associated_data.h"
 #include "net/base/network_change_notifier.h"
 
 namespace {
 
 // The timeout time after which the next tab gets loaded if the previous tab did
 // not finish loading yet. The used value is half of the median value of all
 // ChromeOS devices loading the 25 most common web pages. Half is chosen since
 // the loading time is a mix of server response and data bandwidth.
 static const int kInitialDelayTimerMS = 1500;
 
 class TabLoaderDelegateImpl
     : public TabLoaderDelegate,
       public net::NetworkChangeNotifier::ConnectionTypeObserver {
  public:
   explicit TabLoaderDelegateImpl(TabLoaderCallback* callback);
   ~TabLoaderDelegateImpl() override;
 
   // TabLoaderDelegate:
+  base::TimeDelta GetFirstTabLoadingTimeout() const override {
+    return first_timeout_;
+  }
+
+  // TabLoaderDelegate:
   base::TimeDelta GetTimeoutBeforeLoadingNextTab() const override {
-    return base::TimeDelta::FromMilliseconds(kInitialDelayTimerMS);
+    return timeout_;
   }
 
   // net::NetworkChangeNotifier::ConnectionTypeObserver:
   void OnConnectionTypeChanged(
       net::NetworkChangeNotifier::ConnectionType type) override;
 
  private:
   // The function to call when the connection type changes.
   TabLoaderCallback* callback_;
 
+  // The timeouts to use in tab loading.
+  base::TimeDelta first_timeout_;
+  base::TimeDelta timeout_;
+
   DISALLOW_COPY_AND_ASSIGN(TabLoaderDelegateImpl);
 };
 
 TabLoaderDelegateImpl::TabLoaderDelegateImpl(TabLoaderCallback* callback)
     : callback_(callback) {
   net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
   if (net::NetworkChangeNotifier::IsOffline()) {
     // When we are off-line we do not allow loading of tabs, since each of
     // these tabs would start loading simultaneously when going online.
     // TODO(skuhne): Once we get a higher level resource control logic which
     // distributes network access, we can remove this.
     callback->SetTabLoadingEnabled(false);
   }
+
+  // Initialize the timeouts to use from the session restore field trial.
+  // Default to the usual value if none is specified.
+
+  static const char kIntelligentSessionRestore[] = "IntelligentSessionRestore";
+  std::string timeout = variations::GetVariationParamValue(
+      kIntelligentSessionRestore, "FirstTabLoadTimeoutMs");
+  int timeout_ms = 0;
+  if (timeout.empty() || !base::StringToInt(timeout, &timeout_ms) ||
+      timeout_ms <= 0) {
+    timeout_ms = kInitialDelayTimerMS;
+  }
+  first_timeout_ = base::TimeDelta::FromMilliseconds(timeout_ms);
+
+  timeout = variations::GetVariationParamValue(
+      kIntelligentSessionRestore, "TabLoadTimeoutMs");
+  timeout_ms = 0;
+  if (timeout.empty() || !base::StringToInt(timeout, &timeout_ms) ||
+      timeout_ms <= 0) {
+    timeout_ms = kInitialDelayTimerMS;
+  }
+  timeout_ = base::TimeDelta::FromMilliseconds(timeout_ms);
 }
 
 TabLoaderDelegateImpl::~TabLoaderDelegateImpl() {
   net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
 }
 
 void TabLoaderDelegateImpl::OnConnectionTypeChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
   callback_->SetTabLoadingEnabled(
       type != net::NetworkChangeNotifier::CONNECTION_NONE);
 }
 }  // namespace
 
 // static
 scoped_ptr<TabLoaderDelegate> TabLoaderDelegate::Create(
     TabLoaderCallback* callback) {
   return scoped_ptr<TabLoaderDelegate>(
       new TabLoaderDelegateImpl(callback));
 }