Pepper proxy: make the browser sender handle the proxy lock properly.

ppapi/proxy/plugin_globals.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.
 
 #include "ppapi/proxy/plugin_globals.h"
 
+#include "ipc/ipc_message.h"
+#include "ipc/ipc_sender.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_proxy_delegate.h"
 #include "ppapi/proxy/ppb_message_loop_proxy.h"
+#include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/thunk/enter.h"
 
 namespace ppapi {
 namespace proxy {
 
+// It performs necessary locking/unlocking of the proxy lock, and forwards all
+// messages to the underlying sender.
+class PluginGlobals::BrowserSender : public IPC::Sender {
+ public:
+  // |underlying_sender| must outlive this object.
+  explicit BrowserSender(IPC::Sender* underlying_sender)
+      : underlying_sender_(underlying_sender) {
+  }
+
+  virtual ~BrowserSender() {}
+
+  // IPC::Sender implementation.
+  virtual bool Send(IPC::Message* msg) OVERRIDE {
+    if (msg->is_sync()) {
+      // Synchronous messages might be re-entrant, so we need to drop the lock.
+      ProxyAutoUnlock unlock;
+      return underlying_sender_->Send(msg);
+    }
+
+    return underlying_sender_->Send(msg);
+  }
+
+ private:
+  // Non-owning pointer.
+  IPC::Sender* underlying_sender_;
+
+  DISALLOW_COPY_AND_ASSIGN(BrowserSender);
+};
+
 PluginGlobals* PluginGlobals::plugin_globals_ = NULL;
 
 PluginGlobals::PluginGlobals()
     : ppapi::PpapiGlobals(),
       plugin_proxy_delegate_(NULL),
       callback_tracker_(new CallbackTracker),
       loop_for_main_thread_(
           new MessageLoopResource(MessageLoopResource::ForMainThread())) {
   DCHECK(!plugin_globals_);
   plugin_globals_ = this;
@@ skipping 44 matching lines @@
 PP_Module PluginGlobals::GetModuleForInstance(PP_Instance instance) {
   // Currently proxied plugins don't use the PP_Module for anything useful.
   return 0;
 }
 
 std::string PluginGlobals::GetCmdLine() {
   return command_line_;
 }
 
 void PluginGlobals::PreCacheFontForFlash(const void* logfontw) {
+  ProxyAutoUnlock unlock;

[yzshen1, 2012/11/22 00:42:29]

This is a little ugly, because unlocking here implies that we know about the
internal implementation of plugin_proxy_delegate_->PreCacheFont(). However, I
cannot think up a better solution:
- I cannot send ChildProcessHostMsg_PreCacheFont directly in this file,
otherwise it needs to depend on the content common target;
- I cannot create a new message, say, PpapiHostMsg_PreCacheFont and let
PpapiPluginProcessHost do the work. (It is hard to access the font cache there.)
- Letting PpapiThread call PluginGlobals::Get()->GetBrowserSender() sounds ugly
as well.


Please let me know if you have a better idea. Thanks! :)

   plugin_proxy_delegate_->PreCacheFont(logfontw);
 }
 
 base::Lock* PluginGlobals::GetProxyLock() {
 #ifdef ENABLE_PEPPER_THREADING
   return &proxy_lock_;
 #else
   return NULL;
 #endif
 }
@@ skipping 13 matching lines @@
   // Since we have only one module in a plugin process, broadcast is always
   // the same as "send to everybody" which is what the dispatcher implements
   // for the "instance = 0" case.
   LogWithSource(0, level, source, value);
 }
 
 MessageLoopShared* PluginGlobals::GetCurrentMessageLoop() {
   return MessageLoopResource::GetCurrent();
 }
 
+IPC::Sender* PluginGlobals::GetBrowserSender() {
+  if (!browser_sender_.get()) {
+    browser_sender_.reset(
+        new BrowserSender(plugin_proxy_delegate_->GetBrowserSender()));
+  }
+
+  return browser_sender_.get();
+}
+
+std::string PluginGlobals::GetUILanguage() {
+  return plugin_proxy_delegate_->GetUILanguage();
+}
+
+void PluginGlobals::SetActiveURL(const std::string& url) {
+  plugin_proxy_delegate_->SetActiveURL(url);
+}
+
 MessageLoopResource* PluginGlobals::loop_for_main_thread() {
   return loop_for_main_thread_.get();
 }
 
 bool PluginGlobals::IsPluginGlobals() const {
   return true;
 }
 
 }  // namespace proxy
 }  // namespace ppapi