Revert of Change VirtualTimePolicy::PAUSE_IF_NETWORK_FETCHES_PENDING

components/scheduler/renderer/web_view_scheduler_impl.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 "components/scheduler/renderer/web_view_scheduler_impl.h"
 
 #include "base/logging.h"
-#include "components/scheduler/base/real_time_domain.h"
 #include "components/scheduler/base/virtual_time_domain.h"
 #include "components/scheduler/child/scheduler_tqm_delegate.h"
 #include "components/scheduler/renderer/auto_advancing_virtual_time_domain.h"
 #include "components/scheduler/renderer/renderer_scheduler_impl.h"
 #include "components/scheduler/renderer/web_frame_scheduler_impl.h"
 #include "third_party/WebKit/public/platform/WebFrameScheduler.h"
 #include "third_party/WebKit/public/web/WebConsoleMessage.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebView.h"
 
 namespace scheduler {
 
 WebViewSchedulerImpl::WebViewSchedulerImpl(
     blink::WebView* web_view,
     RendererSchedulerImpl* renderer_scheduler,
     bool disable_background_timer_throttling)
-    : web_view_(web_view),
+    : virtual_time_pump_policy_(TaskQueue::PumpPolicy::AUTO),
+      web_view_(web_view),
       renderer_scheduler_(renderer_scheduler),
       virtual_time_policy_(VirtualTimePolicy::ADVANCE),
       background_parser_count_(0),
       page_visible_(true),
       disable_background_timer_throttling_(disable_background_timer_throttling),
-      allow_virtual_time_to_advance_(true),
-      have_seen_loading_task_(false),
-      virtual_time_(false) {
+      allow_virtual_time_to_advance_(true) {
   renderer_scheduler->AddWebViewScheduler(this);
 }
 
 WebViewSchedulerImpl::~WebViewSchedulerImpl() {
   // TODO(alexclarke): Find out why we can't rely on the web view outliving the
   // frame.
   for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) {
     frame_scheduler->DetachFromWebViewScheduler();
   }
   renderer_scheduler_->RemoveWebViewScheduler(this);
+  if (virtual_time_domain_)
+    renderer_scheduler_->UnregisterTimeDomain(virtual_time_domain_.get());
 }
 
 void WebViewSchedulerImpl::setPageVisible(bool page_visible) {
   if (disable_background_timer_throttling_ || page_visible_ == page_visible)
     return;
 
   page_visible_ = page_visible;
 
   for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) {
     frame_scheduler->setPageVisible(page_visible_);
@@ skipping 23 matching lines @@
 void WebViewSchedulerImpl::AddConsoleWarning(const std::string& message) {
   if (!web_view_ || !web_view_->mainFrame())
     return;
   blink::WebConsoleMessage console_message(
       blink::WebConsoleMessage::LevelWarning,
       blink::WebString::fromUTF8(message));
   web_view_->mainFrame()->addMessageToConsole(console_message);
 }
 
 void WebViewSchedulerImpl::enableVirtualTime() {
-  if (virtual_time_)
+  // If we've already switched to virtual time then we don't need to do
+  // anything more.
+  if (virtual_time_domain_.get())
     return;
 
-  virtual_time_ = true;
-  renderer_scheduler_->GetVirtualTimeDomain()->SetCanAdvanceVirtualTime(
+  virtual_time_domain_.reset(new AutoAdvancingVirtualTimeDomain(
+      renderer_scheduler_->tick_clock()->NowTicks()));
+  renderer_scheduler_->RegisterTimeDomain(virtual_time_domain_.get());
+
+  virtual_time_domain_->SetCanAdvanceVirtualTime(
       allow_virtual_time_to_advance_);
 
-  renderer_scheduler_->EnableVirtualTime();
+  for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) {
+    frame_scheduler->OnVirtualTimeDomainChanged();
+  }
 }
 
 void WebViewSchedulerImpl::setAllowVirtualTimeToAdvance(
     bool allow_virtual_time_to_advance) {
+  if (allow_virtual_time_to_advance_ == allow_virtual_time_to_advance)
+    return;
+
   allow_virtual_time_to_advance_ = allow_virtual_time_to_advance;
 
-  if (!virtual_time_)
-    return;
-
-  renderer_scheduler_->GetVirtualTimeDomain()->SetCanAdvanceVirtualTime(
-      allow_virtual_time_to_advance);
+  if (virtual_time_domain_) {
+    virtual_time_domain_->SetCanAdvanceVirtualTime(
+        allow_virtual_time_to_advance);
+  }
 }
 
 bool WebViewSchedulerImpl::virtualTimeAllowedToAdvance() const {
   return allow_virtual_time_to_advance_;
 }
 
 void WebViewSchedulerImpl::DidStartLoading(unsigned long identifier) {
   pending_loads_.insert(identifier);
-  have_seen_loading_task_ = true;
   ApplyVirtualTimePolicy();
 }
 
 void WebViewSchedulerImpl::DidStopLoading(unsigned long identifier) {
   pending_loads_.erase(identifier);
   ApplyVirtualTimePolicy();
 }
 
 void WebViewSchedulerImpl::IncrementBackgroundParserCount() {
   background_parser_count_++;
@@ skipping 22 matching lines @@
       ApplyVirtualTimePolicy();
       break;
   }
 }
 
 void WebViewSchedulerImpl::ApplyVirtualTimePolicy() {
   if (virtual_time_policy_ != VirtualTimePolicy::DETERMINISTIC_LOADING) {
     return;
   }
 
-  // We pause virtual time until we've seen a loading task posted, because
-  // otherwise we could advance virtual time arbitarially far before the
-  // first load arrives.
   setAllowVirtualTimeToAdvance(pending_loads_.size() == 0 &&
-                               background_parser_count_ == 0 &&
-                               have_seen_loading_task_);
+                               background_parser_count_ == 0);
 }
 
 }  // namespace scheduler