cc: Abstract the LayerTreeHost.

cc/trees/proxy_main.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_main.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/trace_event/trace_event.h"
@@ skipping 30 matching lines @@
       new ProxyMain(layer_tree_host, task_runner_provider));
   proxy_main->SetChannel(RemoteChannelMain::Create(
       remote_proto_channel, proxy_main.get(), task_runner_provider));
   return proxy_main;
 }
 
 ProxyMain::ProxyMain(LayerTreeHost* layer_tree_host,
                      TaskRunnerProvider* task_runner_provider)
     : layer_tree_host_(layer_tree_host),
       task_runner_provider_(task_runner_provider),
-      layer_tree_host_id_(layer_tree_host->id()),
+      layer_tree_host_id_(layer_tree_host->GetId()),
       max_requested_pipeline_stage_(NO_PIPELINE_STAGE),
       current_pipeline_stage_(NO_PIPELINE_STAGE),
       final_pipeline_stage_(NO_PIPELINE_STAGE),
       commit_waits_for_activation_(false),
       started_(false),
       defer_commits_(false) {
   TRACE_EVENT0("cc", "ProxyMain::ProxyMain");
   DCHECK(task_runner_provider_);
   DCHECK(IsMainThread());
 }
@@ skipping 81 matching lines @@
   }
 
   // If the commit finishes, LayerTreeHost will transfer its swap promises to
   // LayerTreeImpl. The destructor of ScopedSwapPromiseChecker aborts the
   // remaining swap promises.
   ScopedAbortRemainingSwapPromises swap_promise_checker(layer_tree_host_);
 
   final_pipeline_stage_ = max_requested_pipeline_stage_;
   max_requested_pipeline_stage_ = NO_PIPELINE_STAGE;
 
-  if (!layer_tree_host_->visible()) {
+  if (!layer_tree_host_->IsVisible()) {
     TRACE_EVENT_INSTANT0("cc", "EarlyOut_NotVisible", TRACE_EVENT_SCOPE_THREAD);
     std::vector<std::unique_ptr<SwapPromise>> empty_swap_promises;
     channel_main_->BeginMainFrameAbortedOnImpl(
         CommitEarlyOutReason::ABORTED_NOT_VISIBLE, begin_main_frame_start_time,
         std::move(empty_swap_promises));
     return;
   }
 
   current_pipeline_stage_ = ANIMATE_PIPELINE_STAGE;
 
@@ skipping 22 matching lines @@
   bool can_cancel_this_commit = final_pipeline_stage_ < COMMIT_PIPELINE_STAGE &&
                                 !begin_main_frame_state->evicted_ui_resources;
 
   current_pipeline_stage_ = UPDATE_LAYERS_PIPELINE_STAGE;
   bool should_update_layers =
       final_pipeline_stage_ >= UPDATE_LAYERS_PIPELINE_STAGE;
   bool updated = should_update_layers && layer_tree_host_->UpdateLayers();
 
   layer_tree_host_->WillCommit();
   devtools_instrumentation::ScopedCommitTrace commit_task(
-      layer_tree_host_->id());
+      layer_tree_host_->GetId());
 
   current_pipeline_stage_ = COMMIT_PIPELINE_STAGE;
   if (!updated && can_cancel_this_commit) {
     TRACE_EVENT_INSTANT0("cc", "EarlyOut_NoUpdates", TRACE_EVENT_SCOPE_THREAD);
     channel_main_->BeginMainFrameAbortedOnImpl(
         CommitEarlyOutReason::FINISHED_NO_UPDATES, begin_main_frame_start_time,
         layer_tree_host_->TakeSwapPromises());
 
     // Although the commit is internally aborted, this is because it has been
     // detected to be a no-op.  From the perspective of an embedder, this commit
@@ skipping 137 matching lines @@
 void ProxyMain::MainThreadHasStoppedFlinging() {
   DCHECK(IsMainThread());
   channel_main_->MainThreadHasStoppedFlingingOnImpl();
 }
 
 void ProxyMain::Start(
     std::unique_ptr<BeginFrameSource> external_begin_frame_source) {
   DCHECK(IsMainThread());
   DCHECK(layer_tree_host_->IsThreaded() || layer_tree_host_->IsRemoteServer());
   DCHECK(channel_main_);
-  DCHECK(!layer_tree_host_->settings().use_external_begin_frame_source ||
+  DCHECK(!layer_tree_host_->GetSettings().use_external_begin_frame_source ||
          external_begin_frame_source);
 
   // Create LayerTreeHostImpl.
   channel_main_->SynchronouslyInitializeImpl(
       layer_tree_host_, std::move(external_begin_frame_source));
 
   started_ = true;
 }
 
 void ProxyMain::Stop() {
@@ skipping 55 matching lines @@
     return false;
   channel_main_->SetNeedsCommitOnImpl();
   return true;
 }
 
 bool ProxyMain::IsMainThread() const {
   return task_runner_provider_->IsMainThread();
 }
 
 }  // namespace cc