Adds a first integration test for the Recent Tabs feature.

components/offline_pages/core/snapshot_controller.cc

 // Copyright 2016 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 "components/offline_pages/core/snapshot_controller.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/time/time.h"
+#include "components/offline_pages/core/offline_page_feature.h"
 
 namespace {
 // Default delay, in milliseconds, between the main document parsed event and
 // snapshot. Note: this snapshot might not occur if the OnLoad event and
 // OnLoad delay elapses first to trigger a final snapshot.
-const size_t kDefaultDelayAfterDocumentAvailableMs = 7000;
+const int64_t kDefaultDelayAfterDocumentAvailableMs = 7000;
 
 // Default delay, in milliseconds, between the main document OnLoad event and
 // snapshot.
-const size_t kDelayAfterDocumentOnLoadCompletedMs = 1000;
+const int64_t kDelayAfterDocumentOnLoadCompletedMs = 1000;
+
+// Delay for testing to keep polling times reasonable.
+const int64_t kDelayForTests = 10;
 
 }  // namespace
 
 namespace offline_pages {
 
 SnapshotController::SnapshotController(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-    SnapshotController::Client* client)
-    : task_runner_(task_runner),
-      client_(client),
-      state_(State::READY),
-      delay_after_document_available_ms_(kDefaultDelayAfterDocumentAvailableMs),
-      delay_after_document_on_load_completed_ms_(
-          kDelayAfterDocumentOnLoadCompletedMs),
-      weak_ptr_factory_(this) {}
-
-SnapshotController::SnapshotController(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     SnapshotController::Client* client,
-    size_t delay_after_document_available_ms,
-    size_t delay_after_document_on_load_completed_ms)
+    int64_t delay_after_document_available_ms,
+    int64_t delay_after_document_on_load_completed_ms)
     : task_runner_(task_runner),
       client_(client),
       state_(State::READY),
       delay_after_document_available_ms_(delay_after_document_available_ms),
       delay_after_document_on_load_completed_ms_(
           delay_after_document_on_load_completed_ms),
-      weak_ptr_factory_(this) {}
+      weak_ptr_factory_(this) {
+  if (offline_pages::ShouldUseTestingSnapshotDelay()) {

[Dmitry Titov, 2017/01/27 03:10:25]

Instead of adding a flag modifying behavior for test, could the test retrieve
the tab, then RecentTabHelper and use the RecentTabHelper::SetDelegate() to set
a delegate that provides a tast version of task_runner which can be advanced
instantly? This can be part of OfflinePageBridge..

[dewittj, 2017/01/30 17:32:37]

That sounds like a lot of plumbing for this test.  Also not sure if it's
appropriate to have a mock-clock type of time in just one component of the
browser. We discussed the need for the quality framework to observe snapshot
conroller, and at that point we will have a more reliable signal and could
remove this flag.  Does that seem ok to you?

+    delay_after_document_available_ms_ = kDelayForTests;
+    delay_after_document_on_load_completed_ms_ = kDelayForTests;
+  }
+}
+
+SnapshotController::SnapshotController(
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    SnapshotController::Client* client)
+    : SnapshotController(task_runner,
+                         client,
+                         kDefaultDelayAfterDocumentAvailableMs,
+                         kDelayAfterDocumentOnLoadCompletedMs) {}
 
 SnapshotController::~SnapshotController() {}
 
 void SnapshotController::Reset() {
   // Cancel potentially delayed tasks that relate to the previous 'session'.
   weak_ptr_factory_.InvalidateWeakPtrs();
   state_ = State::READY;
   current_page_quality_ = PageQuality::POOR;
 }
 
@@ skipping 35 matching lines @@
   current_page_quality_ = updated_page_quality;
   state_ = State::SNAPSHOT_PENDING;
   client_->StartSnapshot();
 }
 
 void SnapshotController::MaybeStartSnapshotThenStop() {
   MaybeStartSnapshot(PageQuality::HIGH);
   Stop();
 }
 
-size_t SnapshotController::GetDelayAfterDocumentAvailableForTest() {
+int64_t SnapshotController::GetDelayAfterDocumentAvailableForTest() {
   return delay_after_document_available_ms_;
 }
 
-size_t SnapshotController::GetDelayAfterDocumentOnLoadCompletedForTest() {
+int64_t SnapshotController::GetDelayAfterDocumentOnLoadCompletedForTest() {
   return delay_after_document_on_load_completed_ms_;
 }
 
 }  // namespace offline_pages