cc: Rename LayerTreeHost to LayerTreeHostInProcess.

cc/layers/picture_layer.cc

 // Copyright 2012 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/layers/picture_layer.h"
 
 #include "base/auto_reset.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/blimp/client_picture_cache.h"
 #include "cc/blimp/engine_picture_cache.h"
@@ skipping 207 matching lines @@
               picture->mutable_recorded_viewport());
   if (picture_layer_inputs_.display_list) {
     picture_layer_inputs_.display_list->ToProtobuf(
         picture->mutable_display_list());
     for (const auto& item : *picture_layer_inputs_.display_list) {
       sk_sp<const SkPicture> picture = item.GetPicture();
       // Only DrawingDisplayItems have SkPictures.
       if (!picture)
         continue;
 
-      layer_tree_host()->engine_picture_cache()->MarkUsed(picture.get());
+      GetLayerTree()->engine_picture_cache()->MarkUsed(picture.get());
     }
   }
 
   RegionToProto(last_updated_invalidation_, picture->mutable_invalidation());
   picture->set_is_mask(is_mask_);
   picture->set_nearest_neighbor(picture_layer_inputs_.nearest_neighbor);
 
   picture->set_update_source_frame_number(update_source_frame_number_);
 
   last_updated_invalidation_.Clear();
 }
 
 void PictureLayer::FromLayerSpecificPropertiesProto(
     const proto::LayerProperties& proto) {
   Layer::FromLayerSpecificPropertiesProto(proto);
   const proto::PictureLayerProperties& picture = proto.picture();
   // If this is a new layer, ensure it has a recording source. During layer
   // hierarchy deserialization, ::SetLayerTreeHost(...) is not called, but
   // instead the member is set directly, so it needs to be set here explicitly.
   if (!recording_source_)
     recording_source_.reset(new RecordingSource);
 
   std::vector<uint32_t> used_engine_picture_ids;
 
   picture_layer_inputs_.recorded_viewport =
       ProtoToRect(picture.recorded_viewport());
 
   ClientPictureCache* client_picture_cache =
-      layer_tree_host()->client_picture_cache();
+      GetLayerTree()->client_picture_cache();
   DCHECK(client_picture_cache);
   // This might not exist if the |input_.display_list| of the serialized
   // RecordingSource was null, which can happen if |Clear()| is
   // called.
   if (picture.has_display_list()) {
     picture_layer_inputs_.display_list = DisplayItemList::CreateFromProto(
         picture.display_list(), client_picture_cache, &used_engine_picture_ids);
   } else {
     picture_layer_inputs_.display_list = nullptr;
   }
 
   recording_source_->FromProtobuf(picture.recording_source(),
                                   picture_layer_inputs_.display_list,
                                   picture_layer_inputs_.recorded_viewport);
 
   // Inform picture cache about which SkPictures are now in use.
   for (uint32_t engine_picture_id : used_engine_picture_ids)
-    layer_tree_host()->client_picture_cache()->MarkUsed(engine_picture_id);
+    GetLayerTree()->client_picture_cache()->MarkUsed(engine_picture_id);
 
   Region new_invalidation = RegionFromProto(picture.invalidation());
   last_updated_invalidation_.Swap(&new_invalidation);
   is_mask_ = picture.is_mask();
   picture_layer_inputs_.nearest_neighbor = picture.nearest_neighbor();
 
   update_source_frame_number_ = picture.update_source_frame_number();
 }
 
 void PictureLayer::RunMicroBenchmark(MicroBenchmark* benchmark) {
@@ skipping 25 matching lines @@
     picture_layer_inputs_.display_list = nullptr;
     picture_layer_inputs_.painter_reported_memory_usage = 0;
   }
 }
 
 const DisplayItemList* PictureLayer::GetDisplayItemList() {
   return picture_layer_inputs_.display_list.get();
 }
 
 }  // namespace cc