gpu: Use mojom API for creating gpu channel.

content/browser/gpu/gpu_process_host.h

 // Copyright (c) 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.
 
 #ifndef CONTENT_BROWSER_GPU_GPU_PROCESS_HOST_H_
 #define CONTENT_BROWSER_GPU_GPU_PROCESS_HOST_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 54 matching lines @@
  public:
   enum GpuProcessKind {
     GPU_PROCESS_KIND_UNSANDBOXED,
     GPU_PROCESS_KIND_SANDBOXED,
     GPU_PROCESS_KIND_COUNT
   };
 
   typedef base::Callback<void(const IPC::ChannelHandle&, const gpu::GPUInfo&)>
       EstablishChannelCallback;
 
-  struct EstablishChannelRequest {
-    EstablishChannelRequest();
-    EstablishChannelRequest(const EstablishChannelRequest& other);
-    ~EstablishChannelRequest();
-    int32_t client_id;
-    EstablishChannelCallback callback;
-  };
-
   typedef base::Callback<void(const gfx::GpuMemoryBufferHandle& handle)>
       CreateGpuMemoryBufferCallback;
 
   static bool gpu_enabled() { return gpu_enabled_; }
   static int gpu_crash_count() { return gpu_crash_count_; }
 
   // Creates a new GpuProcessHost (if |force_create| is turned on) or gets an
   // existing one, resulting in the launching of a GPU process if required.
   // Returns null on failure. It is not safe to store the pointer once control
   // has returned to the message loop as it can be destroyed. Instead store the
@@ skipping 96 matching lines @@
   void DidDestroyChannel(int32_t client_id) override;
   void DidLoseContext(bool offscreen,
                       gpu::error::ContextLostReason reason,
                       const GURL& active_url) override;
   void SetChildSurface(gpu::SurfaceHandle parent,
                        gpu::SurfaceHandle child) override;
   void StoreShaderToDisk(int32_t client_id,
                          const std::string& key,
                          const std::string& shader) override;
 
+  void OnChannelEstablished(int client_id,
+                            const EstablishChannelCallback& callback,
+                            mojo::ScopedMessagePipeHandle channel_handle);
+
   // Message handlers.
   void OnInitialized(bool result,
                      const gpu::GPUInfo& gpu_info,
                      const gpu::GpuFeatureInfo& gpu_feature_info);
-  void OnChannelEstablished(const IPC::ChannelHandle& channel_handle);
   void OnGpuMemoryBufferCreated(const gfx::GpuMemoryBufferHandle& handle);
 #if defined(OS_ANDROID)
   void OnDestroyingVideoSurfaceAck(int surface_id);
 #endif
   void OnFieldTrialActivated(const std::string& trial_name);
 
   void CreateChannelCache(int32_t client_id);
 
   bool LaunchGpuProcess(gpu::GpuPreferences* gpu_preferences);
 
   void SendOutstandingReplies();
 
   void BlockLiveOffscreenContexts();
 
   // Update GPU crash counters.  Disable GPU if crash limit is reached.
   void RecordProcessCrash();
 
   std::string GetShaderPrefixKey(const std::string& shader);
 
   // The serial number of the GpuProcessHost / GpuProcessHostUIShim pair.
   int host_id_;
 
   // These are the channel requests that we have already sent to
   // the GPU process, but haven't heard back about yet.
-  std::queue<EstablishChannelRequest> channel_requests_;
+  std::queue<EstablishChannelCallback> channel_requests_;
 
   // The pending create gpu memory buffer requests we need to reply to.
   std::queue<CreateGpuMemoryBufferCallback> create_gpu_memory_buffer_requests_;
 
   // A callback to signal the completion of a SendDestroyingVideoSurface call.
   base::Closure send_destroying_video_surface_done_cb_;
 
   // Qeueud messages to send when the process launches.
   std::queue<IPC::Message*> queued_messages_;
 
@@ skipping 46 matching lines @@
   typedef std::map<int32_t, scoped_refptr<gpu::ShaderDiskCache>>
       ClientIdToShaderCacheMap;
   ClientIdToShaderCacheMap client_id_to_shader_cache_;
 
   std::string shader_prefix_key_info_;
 
   ui::mojom::GpuMainAssociatedPtr gpu_main_ptr_;
   ui::mojom::GpuServicePtr gpu_service_ptr_;
   mojo::Binding<ui::mojom::GpuHost> gpu_host_binding_;
 
+  base::WeakPtrFactory<GpuProcessHost> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(GpuProcessHost);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_GPU_GPU_PROCESS_HOST_H_