Merge Chromium src@r53293

Change-Id: Ia79acf8670f385cee48c45b0a75371d8e950af34

1 files changed, 185 insertions, 0 deletions

diff --git a/chrome/browser/plugin_process_host.h b/chrome/browser/plugin_process_host.h
new file mode 100644
index 0000000..31d4228
--- /dev/null
+++ b/chrome/browser/plugin_process_host.h
@@ -0,0 +1,185 @@
+// Copyright (c) 2010 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 CHROME_BROWSER_PLUGIN_PROCESS_HOST_H_
+#define CHROME_BROWSER_PLUGIN_PROCESS_HOST_H_
+
+#include "build/build_config.h"
+
+#include <queue>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/scoped_ptr.h"
+#include "chrome/browser/browser_child_process_host.h"
+#include "chrome/browser/net/resolve_proxy_msg_helper.h"
+#include "chrome/browser/renderer_host/resource_message_filter.h"
+#include "gfx/native_widget_types.h"
+#include "ipc/ipc_channel_handle.h"
+#include "webkit/glue/plugins/webplugininfo.h"
+
+namespace gfx {
+class Rect;
+}
+
+class URLRequestContext;
+struct ViewHostMsg_Resource_Request;
+class GURL;
+
+// Represents the browser side of the browser <--> plugin communication
+// channel.  Different plugins run in their own process, but multiple instances
+// of the same plugin run in the same process.  There will be one
+// PluginProcessHost per plugin process, matched with a corresponding
+// PluginProcess running in the plugin process.  The browser is responsible for
+// starting the plugin process when a plugin is created that doesn't already
+// have a process.  After that, most of the communication is directly between
+// the renderer and plugin processes.
+class PluginProcessHost : public BrowserChildProcessHost,
+                          public ResolveProxyMsgHelper::Delegate {
+ public:
+  PluginProcessHost();
+  ~PluginProcessHost();
+
+  // Initialize the new plugin process, returning true on success. This must
+  // be called before the object can be used.
+  bool Init(const WebPluginInfo& info, const std::wstring& locale);
+
+  // Force the plugin process to shutdown (cleanly).
+  void ForceShutdown();
+
+  virtual void OnMessageReceived(const IPC::Message& msg);
+  virtual void OnChannelConnected(int32 peer_pid);
+  virtual void OnChannelError();
+
+  // ResolveProxyMsgHelper::Delegate implementation:
+  virtual void OnResolveProxyCompleted(IPC::Message* reply_msg,
+                                       int result,
+                                       const std::string& proxy_list);
+
+  // Tells the plugin process to create a new channel for communication with a
+  // renderer.  When the plugin process responds with the channel name,
+  // reply_msg is used to send the name to the renderer.
+  void OpenChannelToPlugin(ResourceMessageFilter* renderer_message_filter,
+                           const std::string& mime_type,
+                           IPC::Message* reply_msg);
+
+  // Sends the reply to an open channel request to the renderer with the given
+  // channel name.
+  static void ReplyToRenderer(ResourceMessageFilter* renderer_message_filter,
+                              const IPC::ChannelHandle& channel,
+                              const WebPluginInfo& info,
+                              IPC::Message* reply_msg);
+
+  // This function is called on the IO thread once we receive a reply from the
+  // modal HTML dialog (in the form of a JSON string). This function forwards
+  // that reply back to the plugin that requested the dialog.
+  void OnModalDialogResponse(const std::string& json_retval,
+                             IPC::Message* sync_result);
+
+#if defined(OS_MACOSX)
+  // This function is called on the IO thread when the browser becomes the
+  // active application.
+  void OnAppActivation();
+#endif
+
+  const WebPluginInfo& info() const { return info_; }
+
+#if defined(OS_WIN)
+  // Tracks plugin parent windows created on the browser UI thread.
+  void AddWindow(HWND window);
+#endif
+
+ private:
+  friend class PluginResolveProxyHelper;
+
+  // ResourceDispatcherHost::Receiver implementation:
+  virtual URLRequestContext* GetRequestContext(
+      uint32 request_id,
+      const ViewHostMsg_Resource_Request& request_data);
+
+  // Sends a message to the plugin process to request creation of a new channel
+  // for the given mime type.
+  void RequestPluginChannel(ResourceMessageFilter* renderer_message_filter,
+                            const std::string& mime_type,
+                            IPC::Message* reply_msg);
+
+  virtual void OnProcessLaunched();
+
+  // Message handlers.
+  void OnChannelCreated(const IPC::ChannelHandle& channel_handle);
+  void OnGetPluginFinderUrl(std::string* plugin_finder_url);
+  void OnGetCookies(uint32 request_context, const GURL& url,
+                    std::string* cookies);
+  void OnAccessFiles(int renderer_id, const std::vector<std::string>& files,
+                     bool* allowed);
+  void OnResolveProxy(const GURL& url, IPC::Message* reply_msg);
+  void OnPluginMessage(const std::vector<uint8>& data);
+
+#if defined(OS_WIN)
+  void OnPluginWindowDestroyed(HWND window, HWND parent);
+  void OnDownloadUrl(const std::string& url, int source_child_unique_id,
+                     gfx::NativeWindow caller_window);
+#endif
+
+#if defined(USE_X11)
+  void OnMapNativeViewId(gfx::NativeViewId id, gfx::PluginWindowHandle* output);
+#endif
+
+#if defined(OS_MACOSX)
+  void OnPluginSelectWindow(uint32 window_id, gfx::Rect window_rect,
+                            bool modal);
+  void OnPluginShowWindow(uint32 window_id, gfx::Rect window_rect,
+                          bool modal);
+  void OnPluginHideWindow(uint32 window_id, gfx::Rect window_rect);
+  void OnPluginSetCursorVisibility(bool visible);
+#endif
+
+  virtual bool CanShutdown() { return sent_requests_.empty(); }
+
+  struct ChannelRequest {
+    ChannelRequest(ResourceMessageFilter* renderer_message_filter,
+                   const std::string& m, IPC::Message* r) :
+        mime_type(m), reply_msg(r),
+        renderer_message_filter_(renderer_message_filter) { }
+    std::string mime_type;
+    IPC::Message* reply_msg;
+    scoped_refptr<ResourceMessageFilter> renderer_message_filter_;
+  };
+
+  // These are channel requests that we are waiting to send to the
+  // plugin process once the channel is opened.
+  std::vector<ChannelRequest> pending_requests_;
+
+  // These are the channel requests that we have already sent to
+  // the plugin process, but haven't heard back about yet.
+  std::queue<ChannelRequest> sent_requests_;
+
+  // Information about the plugin.
+  WebPluginInfo info_;
+
+  // Helper class for handling PluginProcessHost_ResolveProxy messages (manages
+  // the requests to the proxy service).
+  ResolveProxyMsgHelper resolve_proxy_msg_helper_;
+
+#if defined(OS_WIN)
+  // Tracks plugin parent windows created on the UI thread.
+  std::set<HWND> plugin_parent_windows_set_;
+#endif
+#if defined(OS_MACOSX)
+  // Tracks plugin windows currently visible.
+  std::set<uint32> plugin_visible_windows_set_;
+  // Tracks full screen windows currently visible.
+  std::set<uint32> plugin_fullscreen_windows_set_;
+  // Tracks modal windows currently visible.
+  std::set<uint32> plugin_modal_windows_set_;
+  // Tracks the current visibility of the cursor.
+  bool plugin_cursor_visible_;
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(PluginProcessHost);
+};
+
+#endif  // CHROME_BROWSER_PLUGIN_PROCESS_HOST_H_