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();

[enne (OOO), 2016/07/18 21:48:02]

Just from a readability perspective, it's a little weird to have this here.  I
would have expected BeginMainFrameCompleted to occur at the end of
BeginMainFrame, and anything happening here to be called StartCommitOnImpl, as
it was called before.

[danakj, 2016/07/18 23:20:10]

It needs to happen before NotifyReadyToCommit and on the impl thread. This
translates to BeginMainFrameCompletedOnThread() in tests which is more clear
(the OnThread part is kinda implicit here).

It's 1:1 with the NotifyBeginMainFrameStarted() to the scheduler, which is to
say main frame is done on the thread.

This function is called StartCommitOnImpl for historical reasons, but it won't
really start a commit, it's more like
"MainThreadIsBlockedAndMainFrameIsDoneOnImpl" or something. Maybe I should
rename it to just BeginMainFrameCompletedOnImpl?

[enne (OOO), 2016/07/19 01:08:59]

DidStartCommitOnImpl?

[danakj, 2016/07/19 01:36:37]

I mean, should I rename the method on ProxyImpl to
ProxyImpl::BeginMainFrameCmopletedOnImpl?

I don't want to call the hook CommitStarted or similar, cuz that's not what this
is. This is the main thread saying it's blocked. Commit happens separately from
this when we deem it worthy. And we have a BeginCommitOnThread hook for that.

+
   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