gpu: Generate mailboxes on client side

content/common/gpu/client/gpu_channel_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_COMMON_GPU_CLIENT_GPU_CHANNEL_HOST_H_
 #define CONTENT_COMMON_GPU_CLIENT_GPU_CHANNEL_HOST_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 20 matching lines @@
 
 class GURL;
 class TransportTextureService;
 struct GPUCreateCommandBufferConfig;
 
 namespace base {
 class MessageLoop;
 class MessageLoopProxy;
 }
 
-namespace gpu {
-struct Mailbox;
-}
-
 namespace IPC {
 class SyncMessageFilter;
 }
 
 namespace content {
 class CommandBufferProxyImpl;
 class GpuChannelHost;
 
 struct GpuListenerInfo {
   GpuListenerInfo();
@@ skipping 89 matching lines @@
   void RemoveRoute(int route_id);
 
   GpuChannelHostFactory* factory() const { return factory_; }
 
   // Returns a handle to the shared memory that can be sent via IPC to the
   // GPU process. The caller is responsible for ensuring it is closed. Returns
   // an invalid handle on failure.
   base::SharedMemoryHandle ShareToGpuProcess(
       base::SharedMemoryHandle source_handle);
 
-  // Generates |num| unique mailbox names that can be used with
-  // GL_texture_mailbox_CHROMIUM. Unlike genMailboxCHROMIUM, this IPC is
-  // handled only on the GPU process' IO thread, and so is not effectively
-  // a finish.
-  bool GenerateMailboxNames(unsigned num, std::vector<gpu::Mailbox>* names);
-
   // Reserve one unused transfer buffer ID.
   int32 ReserveTransferBufferId();
 
   // Returns a GPU memory buffer handle to the buffer that can be sent via
   // IPC to the GPU process. The caller is responsible for ensuring it is
   // closed. Returns an invalid handle on failure.
   gfx::GpuMemoryBufferHandle ShareGpuMemoryBufferToGpuProcess(
       gfx::GpuMemoryBufferHandle source_handle);
 
   // Reserve one unused gpu memory buffer ID.
@@ skipping 23 matching lines @@
     // IPC::ChannelProxy::MessageFilter implementation
     // (called on the IO thread):
     virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
     virtual void OnChannelError() OVERRIDE;
 
     // The following methods can be called on any thread.
 
     // Whether the channel is lost.
     bool IsLost() const;
 
-    // Gets mailboxes from the pool, and return the number of mailboxes to ask
-    // the GPU process to maintain a good pool size. The caller is responsible
-    // for sending the GpuChannelMsg_GenerateMailboxNamesAsync message.
-    size_t GetMailboxNames(size_t num, std::vector<gpu::Mailbox>* names);
-
    private:
     virtual ~MessageFilter();
-    bool OnControlMessageReceived(const IPC::Message& msg);
-
-    // Message handlers.
-    void OnGenerateMailboxNamesReply(const std::vector<gpu::Mailbox>& names);
 
     // Threading notes: |listeners_| is only accessed on the IO thread. Every
     // other field is protected by |lock_|.
     typedef base::hash_map<int, GpuListenerInfo> ListenerMap;
     ListenerMap listeners_;
 
     // Protects all fields below this one.
     mutable base::Lock lock_;
 
     // Whether the channel has been lost.
     bool lost_;
-
-    // A pool of valid mailbox names.
-    std::vector<gpu::Mailbox> mailbox_name_pool_;
-
-    // Number of pending mailbox requested from the GPU process.
-    size_t requested_mailboxes_;
   };
 
   // Threading notes: all fields are constant during the lifetime of |this|
   // except:
   // - |next_transfer_buffer_id_|, atomic type
   // - |next_gpu_memory_buffer_id_|, atomic type
   // - |proxies_|, protected by |context_lock_|
   GpuChannelHostFactory* const factory_;
 
   const gpu::GPUInfo gpu_info_;
@@ skipping 15 matching lines @@
   // Used to look up a proxy from its routing id.
   typedef base::hash_map<int, CommandBufferProxyImpl*> ProxyMap;
   ProxyMap proxies_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuChannelHost);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_CLIENT_GPU_CHANNEL_HOST_H_