Revert 132218 - Convert plugin and GPU process to brokered handle duplication.

content/common/gpu/gpu_channel.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_COMMON_GPU_GPU_CHANNEL_H_
 #define CONTENT_COMMON_GPU_GPU_CHANNEL_H_
 #pragma once
 
 #include <deque>
 #include <string>
@@ skipping 44 matching lines @@
     return gpu_channel_manager_;
   }
 
   // Returns the name of the associated IPC channel.
   std::string GetChannelName();
 
 #if defined(OS_POSIX)
   int TakeRendererFileDescriptor();
 #endif  // defined(OS_POSIX)
 
-  base::ProcessId renderer_pid() const { return channel_->peer_pid(); }
+  base::ProcessHandle renderer_process() const {
+    return renderer_process_;
+  }
 
   // IPC::Channel::Listener implementation:
   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
   virtual void OnChannelError() OVERRIDE;
+  virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
 
   // IPC::Message::Sender implementation:
   virtual bool Send(IPC::Message* msg) OVERRIDE;
 
   virtual void AppendAllCommandBufferStubs(
       std::vector<GpuCommandBufferStubBase*>& stubs);
 
   // This is called when a command buffer transitions from the unscheduled
   // state to the scheduled state, which potentially means the channel
   // transitions from the unscheduled to the scheduled state. When this occurs
@@ skipping 29 matching lines @@
  private:
   void OnDestroy();
 
   bool OnControlMessageReceived(const IPC::Message& msg);
 
   void HandleMessage();
   void PollWork(int route_id);
   void ScheduleDelayedWork(GpuCommandBufferStub *stub, int64 delay);
 
   // Message handlers.
+  void OnInitialize(base::ProcessHandle renderer_process);
   void OnCreateOffscreenCommandBuffer(
       const gfx::Size& size,
       const GPUCreateCommandBufferConfig& init_params,
       IPC::Message* reply_message);
   void OnDestroyCommandBuffer(int32 route_id, IPC::Message* reply_message);
 
   void OnWillGpuSwitchOccur(bool is_creating_context,
                             gfx::GpuPreference gpu_preference,
                             IPC::Message* reply_message);
   void OnCloseChannel();
 
   void WillCreateCommandBuffer(gfx::GpuPreference gpu_preference);
   void DidDestroyCommandBuffer(gfx::GpuPreference gpu_preference);
 
   // The lifetime of objects of this class is managed by a GpuChannelManager.
   // The GpuChannelManager destroy all the GpuChannels that they own when they
   // are destroyed. So a raw pointer is safe.
   GpuChannelManager* gpu_channel_manager_;
 
   scoped_ptr<IPC::SyncChannel> channel_;
 
   std::deque<IPC::Message*> deferred_messages_;
 
   // The id of the client who is on the other side of the channel.
   int client_id_;
 
   // Uniquely identifies the channel within this GPU process.
   std::string channel_id_;
 
+  // Handle to the renderer process that is on the other side of the channel.
+  base::ProcessHandle renderer_process_;
+
+  // The process id of the renderer process.
+  base::ProcessId renderer_pid_;
+
   // Used to implement message routing functionality to CommandBuffer objects
   MessageRouter router_;
 
   // The share group that all contexts associated with a particular renderer
   // process use.
   scoped_refptr<gfx::GLShareGroup> share_group_;
 
 #if defined(ENABLE_GPU)
   typedef IDMap<GpuCommandBufferStub, IDMapOwnPointer> StubMap;
   StubMap stubs_;
 #endif  // defined (ENABLE_GPU)
 
   bool log_messages_;  // True if we should log sent and received messages.
   gpu::gles2::DisallowedFeatures disallowed_features_;
   GpuWatchdog* watchdog_;
   bool software_;
   bool handle_messages_scheduled_;
   bool processed_get_state_fast_;
   int32 num_contexts_preferring_discrete_gpu_;
 
   base::WeakPtrFactory<GpuChannel> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuChannel);
 };
 
 #endif  // CONTENT_COMMON_GPU_GPU_CHANNEL_H_