IPC to generate mailbox names on the GPU process IO thread.

content/common/gpu/gpu_channel.cc

 // 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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/common/gpu/gpu_channel.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop_proxy.h"
 #include "base/process_util.h"
+#include "base/rand_util.h"
 #include "base/string_util.h"
 #include "content/common/child_process.h"
 #include "content/common/gpu/gpu_channel_manager.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/sync_point_manager.h"
 #include "content/public/common/content_switches.h"
+#include "crypto/hmac.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_surface.h"
 
 #if defined(OS_POSIX)
@@ skipping 104 matching lines @@
   // NOTE: this is a pointer to a weak pointer. It is never dereferenced on the
   // IO thread, it's only passed through - therefore the WeakPtr assumptions are
   // respected.
   base::WeakPtr<GpuChannel>* gpu_channel_;
   IPC::Channel* channel_;
   scoped_refptr<SyncPointManager> sync_point_manager_;
   scoped_refptr<base::MessageLoopProxy> message_loop_;
   scoped_refptr<gpu::RefCountedCounter> unprocessed_messages_;
 };
 
+// Generates mailbox names for clients of the GPU process on the IO thread.
+class MailboxMessageFilter : public IPC::ChannelProxy::MessageFilter {
+ public:
+  explicit MailboxMessageFilter(const std::string& private_key)
+      : channel_(NULL),
+        hmac_(crypto::HMAC::SHA256) {
+    bool success = hmac_.Init(base::StringPiece(private_key));
+    DCHECK(success);
+  }
+
+  virtual void OnFilterAdded(IPC::Channel* channel) {
+    DCHECK(!channel_);
+    channel_ = channel;
+  }
+
+  virtual void OnFilterRemoved() {
+    DCHECK(channel_);
+    channel_ = NULL;
+  }
+
+  virtual bool OnMessageReceived(const IPC::Message& message) {
+    DCHECK(channel_);
+
+    bool handled = true;
+    IPC_BEGIN_MESSAGE_MAP(MailboxMessageFilter, message)
+      IPC_MESSAGE_HANDLER(GpuChannelMsg_GenerateMailboxNames,
+                          OnGenerateMailboxNames)
+      IPC_MESSAGE_UNHANDLED(handled = false)
+    IPC_END_MESSAGE_MAP()
+
+    return handled;
+  }
+
+  bool Send(IPC::Message* message) {
+    return channel_->Send(message);
+  }
+
+ private:
+  ~MailboxMessageFilter() {
+  }
+
+  // Message handlers.
+  void OnGenerateMailboxNames(unsigned num, std::vector<std::string>* result) {
+    TRACE_EVENT1("gpu", "OnGenerateMailboxNames", "num", num);
+
+    result->resize(num);
+
+    for (unsigned i = 0; i < num; ++i) {
+      char name[GL_MAILBOX_SIZE_CHROMIUM];
+      base::RandBytes(name, sizeof(name) / 2);
+
+      bool success = hmac_.Sign(
+          base::StringPiece(name, sizeof(name) / 2),
+          reinterpret_cast<unsigned char*>(name) + sizeof(name) / 2,
+          sizeof(name) / 2);
+      DCHECK(success);
+
+      (*result)[i].assign(name, sizeof(name));
+    }
+  }
+
+  IPC::Channel* channel_;
+  crypto::HMAC hmac_;
+};
 }  // anonymous namespace
 
 GpuChannel::GpuChannel(GpuChannelManager* gpu_channel_manager,
                        GpuWatchdog* watchdog,
                        gfx::GLShareGroup* share_group,
                        gpu::gles2::MailboxManager* mailbox,
                        int client_id,
                        bool software)
     : gpu_channel_manager_(gpu_channel_manager),
       unprocessed_messages_(new gpu::RefCountedCounter),
@@ skipping 35 matching lines @@
 
   base::WeakPtr<GpuChannel>* weak_ptr(new base::WeakPtr<GpuChannel>(
       weak_factory_.GetWeakPtr()));
   scoped_refptr<SyncPointMessageFilter> filter(new SyncPointMessageFilter(
       weak_ptr,
       gpu_channel_manager_->sync_point_manager(),
       base::MessageLoopProxy::current(),
       unprocessed_messages_));
   channel_->AddFilter(filter);
 
+  channel_->AddFilter(
+      new MailboxMessageFilter(mailbox_manager_->private_key()));
+
   return true;
 }
 
 std::string GpuChannel::GetChannelName() {
   return channel_id_;
 }
 
 #if defined(OS_POSIX)
 int GpuChannel::TakeRendererFileDescriptor() {
   if (!channel_.get()) {
@@ skipping 392 matching lines @@
     }
   }
 
   GpuChannelMsg_CollectRenderingStatsForSurface::WriteReplyParams(
       reply_message,
       stats);
   Send(reply_message);
 }
 
 }  // namespace content