cc: Rename LayerTreeHost to LayerTreeHostInProcess.

cc/trees/remote_channel_impl.h

 // Copyright 2016 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.
 
 #ifndef CC_TREES_REMOTE_CHANNEL_IMPL_H_
 #define CC_TREES_REMOTE_CHANNEL_IMPL_H_
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/completion_event.h"
 #include "cc/proto/compositor_message_to_impl.pb.h"
 #include "cc/trees/channel_impl.h"
 #include "cc/trees/proxy.h"
 #include "cc/trees/proxy_impl.h"
 #include "cc/trees/remote_proto_channel.h"
 
 namespace cc {
-class LayerTreeHost;
+class LayerTreeHostInProcess;
 
 namespace proto {
 class CompositorMessage;
 class CompositorMessageToImpl;
 class CompositorMessageToMain;
 }
 
 // The Proxy and ChannelImpl implementation for the remote compositor.
 // The object life cycle and communication across threads is as follows:
 //
@@ skipping 33 matching lines @@
 // the impl thread since:
 // 1) The only impl threaded callers of RemoteChannelImpl is the
 // RemoteChannelImpl itself and ProxyImpl which is created and owned by the
 // RemoteChannelImpl.
 // 2) The RemoteChannelImpl blocks the main thread in its dtor to wait for the
 // impl-thread teardown to complete, which ensures that any tasks queued to call
 // it on the impl thread are run before it is destroyed on the main thread.
 //
 // The RemoteChannelImpl receives and processes messages from the remote server
 // compositor on the main thread. The requests from ProxyImpl are received on
-// the impl thread which may be directed to the LayerTreeHost on the client
-// (for instance output surface requests) or sent to the LayerTreeHost on the
-// server. The messages to the server are created on the impl thread and sent
-// using the RemoteProtoChannel on the main thread.
+// the impl thread which may be directed to the LayerTreeHostInProcesson the
+// client (for instance output surface requests) or sent to the
+// LayerTreeHostInProcess on the server. The messages to the server are created
+// on the impl thread and sent using the RemoteProtoChannel on the main thread.
 class CC_EXPORT RemoteChannelImpl : public ChannelImpl,
                                     public RemoteProtoChannel::ProtoReceiver,
                                     public Proxy {
  public:
-  RemoteChannelImpl(LayerTreeHost* layer_tree_host,
+  RemoteChannelImpl(LayerTreeHostInProcess* layer_tree_host,
                     RemoteProtoChannel* remote_proto_channel,
                     TaskRunnerProvider* task_runner_provider);
   ~RemoteChannelImpl() override;
 
   // virtual for testing.
   virtual std::unique_ptr<ProxyImpl> CreateProxyImpl(
       ChannelImpl* channel_impl,
-      LayerTreeHost* layer_tree_host,
+      LayerTreeHostInProcess* layer_tree_host,
       TaskRunnerProvider* task_runner_provider,
       std::unique_ptr<BeginFrameSource> external_begin_frame_source);
 
  private:
   struct MainThreadOnly {
-    LayerTreeHost* layer_tree_host;
+    LayerTreeHostInProcess* layer_tree_host;
     RemoteProtoChannel* remote_proto_channel;
 
     bool started;
 
     // This is set to true if we lost the output surface and can not push any
     // commits to the impl thread.
     bool waiting_for_compositor_frame_sink_initialization;
 
     // The queue of messages received from the server. The messages are added to
     // this queue if we are waiting for a new output surface to be initialized.
     std::queue<proto::CompositorMessageToImpl> pending_messages;
 
     base::WeakPtrFactory<RemoteChannelImpl> remote_channel_weak_factory;
 
     MainThreadOnly(RemoteChannelImpl*,
-                   LayerTreeHost* layer_tree_host,
+                   LayerTreeHostInProcess* layer_tree_host,
                    RemoteProtoChannel* remote_proto_channel);
     ~MainThreadOnly();
   };
 
   struct CompositorThreadOnly {
     std::unique_ptr<ProxyImpl> proxy_impl;
     std::unique_ptr<base::WeakPtrFactory<ProxyImpl>> proxy_impl_weak_factory;
     base::WeakPtr<RemoteChannelImpl> remote_channel_weak_ptr;
 
     CompositorThreadOnly(
@@ skipping 52 matching lines @@
   void HandleProto(const proto::CompositorMessageToImpl& proto);
   void DidCompleteSwapBuffersOnMain();
   void DidCommitAndDrawFrameOnMain();
   void DidLoseCompositorFrameSinkOnMain();
   void RequestNewCompositorFrameSinkOnMain();
   void DidInitializeCompositorFrameSinkOnMain(bool success);
   void SendMessageProtoOnMain(std::unique_ptr<proto::CompositorMessage> proto);
   void PostSetNeedsRedrawToImpl(const gfx::Rect& damaged_rect);
 
   void InitializeImplOnImpl(CompletionEvent* completion,
-                            LayerTreeHost* layer_tree_host);
+                            LayerTreeHostInProcess* layer_tree_host);
   void ShutdownImplOnImpl(CompletionEvent* completion);
 
   MainThreadOnly& main();
   const MainThreadOnly& main() const;
   CompositorThreadOnly& impl();
   const CompositorThreadOnly& impl() const;
 
   base::SingleThreadTaskRunner* MainThreadTaskRunner() const;
   base::SingleThreadTaskRunner* ImplThreadTaskRunner() const;
 
   TaskRunnerProvider* task_runner_provider_;
 
   // use accessors instead of these variables directly
   MainThreadOnly main_thread_vars_unsafe_;
   CompositorThreadOnly compositor_thread_vars_unsafe_;
 
   base::WeakPtr<ProxyImpl> proxy_impl_weak_ptr_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoteChannelImpl);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_REMOTE_CHANNEL_IMPL_H_