cc: Clean up LayerTreeTest and TestHooks.

cc/trees/proxy_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 "cc/trees/proxy_impl.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 18 matching lines @@
 
 namespace {
 
 // Measured in seconds.
 const double kSmoothnessTakesPriorityExpirationDelay = 0.25;
 
 unsigned int nextBeginFrameId = 0;
 
 }  // namespace
 
-std::unique_ptr<ProxyImpl> ProxyImpl::Create(
-    ChannelImpl* channel_impl,
-    LayerTreeHost* layer_tree_host,
-    TaskRunnerProvider* task_runner_provider,
-    std::unique_ptr<BeginFrameSource> external_begin_frame_source) {
-  return base::WrapUnique(
-      new ProxyImpl(channel_impl, layer_tree_host, task_runner_provider,
-                    std::move(external_begin_frame_source)));
-}
-
 ProxyImpl::ProxyImpl(
     ChannelImpl* channel_impl,
     LayerTreeHost* layer_tree_host,
     TaskRunnerProvider* task_runner_provider,
     std::unique_ptr<BeginFrameSource> external_begin_frame_source)
     : layer_tree_host_id_(layer_tree_host->id()),
       commit_completion_waits_for_activation_(false),
       commit_completion_event_(nullptr),
       activation_completion_event_(nullptr),
       next_frame_is_newly_committed_frame_(false),
       inside_draw_(false),
       input_throttled_until_commit_(false),
       task_runner_provider_(task_runner_provider),
       smoothness_priority_expiration_notifier_(
           task_runner_provider->ImplThreadTaskRunner(),
           base::Bind(&ProxyImpl::RenewTreePriority, base::Unretained(this)),
           base::TimeDelta::FromSecondsD(
               kSmoothnessTakesPriorityExpirationDelay)),
       external_begin_frame_source_(std::move(external_begin_frame_source)),
       rendering_stats_instrumentation_(
           layer_tree_host->rendering_stats_instrumentation()),
       channel_impl_(channel_impl) {
   TRACE_EVENT0("cc", "ProxyImpl::ProxyImpl");
   DCHECK(IsImplThread());
   DCHECK(IsMainThreadBlocked());
 
+  // Double checking we set this correctly since double->int truncations are
+  // silent and have been done mistakenly: crbug.com/568120.
+  DCHECK(!smoothness_priority_expiration_notifier_.delay().is_zero());
+
   layer_tree_host_impl_ = layer_tree_host->CreateLayerTreeHostImpl(this);
 
   SchedulerSettings scheduler_settings(
       layer_tree_host->settings().ToSchedulerSettings());
 
   std::unique_ptr<CompositorTimingHistory> compositor_timing_history(
       new CompositorTimingHistory(
           scheduler_settings.using_synchronous_renderer_compositor,
           CompositorTimingHistory::RENDERER_UMA,
           rendering_stats_instrumentation_));
@@ skipping 164 matching lines @@
     bool* main_frame_will_happen) {
   DCHECK(IsImplThread());
   if (layer_tree_host_impl_->output_surface()) {
     *main_frame_will_happen = scheduler_->MainFrameForTestingWillHappen();
   } else {
     *main_frame_will_happen = false;
   }
   completion->Signal();
 }
 
-void ProxyImpl::BlockNotifyReadyToActivateForTesting(bool block) {
-  DCHECK(IsImplThread());
-  layer_tree_host_impl_->BlockNotifyReadyToActivateForTesting(block);
-}
-
-CompletionEvent* ProxyImpl::ActivationCompletionEventForTesting() {
-  DCHECK(IsImplThread());
-  return activation_completion_event_;
-}
-
 void ProxyImpl::StartCommitOnImpl(CompletionEvent* completion,
                                   LayerTreeHost* layer_tree_host,
                                   base::TimeTicks main_thread_start_time,
                                   bool hold_commit_for_activation) {
   TRACE_EVENT0("cc", "ProxyImpl::StartCommitOnImplThread");
   DCHECK(!commit_completion_event_);
   DCHECK(IsImplThread() && IsMainThreadBlocked());
   DCHECK(scheduler_);
   DCHECK(scheduler_->CommitPending());
 
   if (!layer_tree_host_impl_) {
     TRACE_EVENT_INSTANT0("cc", "EarlyOut_NoLayerTree",
                          TRACE_EVENT_SCOPE_THREAD);
     completion->Signal();
     return;
   }
 
   // Ideally, we should inform to impl thread when BeginMainFrame is started.
   // But, we can avoid a PostTask in here.
   scheduler_->NotifyBeginMainFrameStarted(main_thread_start_time);
 
+  layer_tree_host_impl_->BeginMainFrameCompleted();
+
   commit_completion_event_ = completion;
   commit_completion_waits_for_activation_ = hold_commit_for_activation;
 
   DCHECK(!blocked_main_commit().layer_tree_host);
   blocked_main_commit().layer_tree_host = layer_tree_host;
   scheduler_->NotifyReadyToCommit();
 }
 
 void ProxyImpl::UpdateRendererCapabilitiesOnImplThread() {
   DCHECK(IsImplThread());
@@ skipping 377 matching lines @@
 bool ProxyImpl::IsMainThreadBlocked() const {
   return task_runner_provider_->IsMainThreadBlocked();
 }
 
 ProxyImpl::BlockedMainCommitOnly& ProxyImpl::blocked_main_commit() {
   DCHECK(IsMainThreadBlocked() && commit_completion_event_);
   return main_thread_blocked_commit_vars_unsafe_;
 }
 
 }  // namespace cc