Split GpuProcessHost into GpuProcessHostUIShim, which runs on the UI...

chrome/browser/gpu_process_host.h

 // Copyright (c) 2010 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 CHROME_BROWSER_GPU_PROCESS_HOST_H_
 #define CHROME_BROWSER_GPU_PROCESS_HOST_H_
 
 #include <queue>
 
 #include "base/basictypes.h"
 #include "base/scoped_ptr.h"
-#include "base/singleton.h"
-#include "chrome/browser/child_process_launcher.h"
-#include "chrome/common/gpu_native_window_handle.h"
-#include "chrome/common/message_router.h"
-#include "gfx/native_widget_types.h"
-#include "ipc/ipc_channel_handle.h"
-#include "ipc/ipc_channel_proxy.h"
+#include "chrome/browser/child_process_host.h"
+#include "chrome/browser/renderer_host/resource_message_filter.h"
 
 class ChildProcessLauncher;
 class CommandBufferProxy;
 
-class GpuProcessHost : public IPC::Channel::Sender,
-                       public IPC::Channel::Listener,
-                       public ChildProcessLauncher::Client {
+class GpuProcessHost : public ChildProcessHost {
  public:
   // Getter for the singleton. This will return NULL on failure.
   static GpuProcessHost* Get();
 
-  int32 GetNextRoutingId();
+  // Shutdown routine, which should only be called upon process
+  // termination.
+  static void Shutdown();
 
-  // Creates the new remote view and returns the routing ID for the view, or 0
-  // on failure.
-  int32 NewRenderWidgetHostView(GpuNativeWindowHandle parent);
-
-  // IPC::Channel::Sender implementation.
   virtual bool Send(IPC::Message* msg);
 
   // IPC::Channel::Listener implementation.
   virtual void OnMessageReceived(const IPC::Message& message);
-  virtual void OnChannelConnected(int32 peer_pid);
-  virtual void OnChannelError();
-
-  // ChildProcessLauncher::Client implementation.
-  virtual void OnProcessLaunched();
-
-  // See documentation on MessageRouter for AddRoute and RemoveRoute
-  void AddRoute(int32 routing_id, IPC::Channel::Listener* listener);
-  void RemoveRoute(int32 routing_id);
 
   // Tells the GPU process to create a new channel for communication with a
   // renderer. Will asynchronously send message to object with given routing id
   // on completion.
-  void EstablishGpuChannel(int renderer_id);
+  void EstablishGpuChannel(int renderer_id,
+                           ResourceMessageFilter* filter);
 
   // Sends a reply message later when the next GpuHostMsg_SynchronizeReply comes
   // in.
-  void Synchronize(int renderer_id, IPC::Message* reply);
+  void Synchronize(IPC::Message* reply,
+                   ResourceMessageFilter* filter);
 
  private:
-  friend struct DefaultSingletonTraits<GpuProcessHost>;
-
   // Used to queue pending channel requests.
   struct ChannelRequest {
-    explicit ChannelRequest(int renderer_id) : renderer_id(renderer_id) {}
-    // Used to identify the renderer. The ID is used instead of a pointer to
-    // the RenderProcessHost in case it is destroyed while the request is
-    // pending.
-    // TODO(apatrick): investigate whether these IDs are used for future
-    // render processes.
-    int renderer_id;
+    explicit ChannelRequest(ResourceMessageFilter* filter)
+        : filter(filter) {}
+    // Used to send the reply message back to the renderer.
+    scoped_refptr<ResourceMessageFilter> filter;
+  };
+
+  // Used to queue pending synchronization requests.
+  struct SynchronizationRequest {
+    SynchronizationRequest(IPC::Message* reply,
+                           ResourceMessageFilter* filter)
+        : reply(reply),
+          filter(filter) {}
+    // The delayed reply message which needs to be sent to the
+    // renderer.
+    IPC::Message* reply;
+
+    // Used to send the reply message back to the renderer.
+    scoped_refptr<ResourceMessageFilter> filter;
   };
 
   GpuProcessHost();
   virtual ~GpuProcessHost();
 
+  bool EnsureInitialized();
+  bool Init();
+
   void OnControlMessageReceived(const IPC::Message& message);
 
   // Message handlers.
   void OnChannelEstablished(const IPC::ChannelHandle& channel_handle);
-  void OnSynchronizeReply(int renderer_id);
+  void OnSynchronizeReply();
 
-  void ReplyToRenderer(int renderer_id,
-                       const IPC::ChannelHandle& channel);
-
-  // These are the channel requests that we have already sent to
-  // the GPU process, but haven't heard back about yet.
-  std::queue<ChannelRequest> sent_requests_;
+  void ReplyToRenderer(const IPC::ChannelHandle& channel,
+                       ResourceMessageFilter* filter);
 
   // Copies applicable command line switches from the given |browser_cmd| line
   // flags to the output |gpu_cmd| line flags. Not all switches will be
   // copied over.
   void PropagateBrowserCommandLineToGpu(const CommandLine& browser_cmd,
                                         CommandLine* gpu_cmd) const;
 
-  scoped_ptr<ChildProcessLauncher> child_process_;
+  // ResourceDispatcherHost::Receiver implementation:
+  virtual URLRequestContext* GetRequestContext(
+      uint32 request_id,
+      const ViewHostMsg_Resource_Request& request_data);
 
-  // A proxy for our IPC::Channel that lives on the IO thread (see
-  // browser_process.h). This will be NULL if the class failed to connect.
-  scoped_ptr<IPC::ChannelProxy> channel_;
+  virtual bool CanShutdown();
 
-  int last_routing_id_;
+  bool initialized_;
+  bool initialized_successfully_;
 
-  MessageRouter router_;
-
-  // Messages we queue while waiting for the process handle.  We queue them here
-  // instead of in the channel so that we ensure they're sent after init related
-  // messages that are sent once the process handle is available.  This is
-  // because the queued messages may have dependencies on the init messages.
-  std::queue<IPC::Message*> queued_messages_;
+  // These are the channel requests that we have already sent to
+  // the GPU process, but haven't heard back about yet.
+  std::queue<ChannelRequest> sent_requests_;
 
   // The pending synchronization requests we need to reply to.
-  std::queue<IPC::Message*> queued_synchronization_replies_;
+  std::queue<SynchronizationRequest> queued_synchronization_replies_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuProcessHost);
 };
 
 #endif  // CHROME_BROWSER_GPU_PROCESS_HOST_H_