Make chrome_plugin_host.cc and chrome_plugin_util.cc compile on Posix.

chrome/browser/chrome_plugin_host.cc

 // Copyright (c) 2006-2008 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 "chrome/browser/chrome_plugin_host.h"
 
 #include <set>
 
+#include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/gfx/png_encoder.h"
 #include "base/histogram.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/perftimer.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/chrome_plugin_browsing_context.h"
 #include "chrome/browser/chrome_thread.h"
-#include "chrome/browser/dom_ui/html_dialog_contents.h"
 #include "chrome/browser/gears_integration.h"
 #include "chrome/browser/plugin_process_host.h"
 #include "chrome/browser/plugin_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_counters.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_plugin_lib.h"
 #include "chrome/common/chrome_plugin_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/gears_api.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/net/url_request_intercept_job.h"
-#include "chrome/common/plugin_messages.h"
 #include "chrome/common/render_messages.h"
 #include "net/base/base64.h"
 #include "net/base/cookie_monster.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_error_job.h"
 #include "skia/include/SkBitmap.h"
 
+// TODO(port): Port these files.
+#if defined(OS_WIN)
+#include "chrome/browser/dom_ui/html_dialog_contents.h"
+#include "chrome/common/plugin_messages.h"
+#else
+#include "chrome/common/temp_scaffolding_stubs.h"
+#endif
+
 using base::TimeDelta;
 
 // This class manages the interception of network requests.  It queries the
 // plugin on every request, and creates an intercept job if the plugin can
 // intercept the request.
 // NOTE: All methods must be called on the IO thread.
 class PluginRequestInterceptor
     : public PluginHelper, public URLRequest::Interceptor {
  public:
   static URLRequestJob* UninterceptedProtocolHandler(
@@ skipping 222 matching lines @@
 // on demand on the plugin thread, and proxies calls to and from the UI thread
 // to display the UI.
 class ModelessHtmlDialogDelegate : public HtmlDialogContentsDelegate {
  public:
   ModelessHtmlDialogDelegate(const GURL& url,
                              int width, int height,
                              const std::string& json_arguments,
                              void* plugin_context,
                              ChromePluginLib* plugin,
                              MessageLoop* main_message_loop,
-                             HWND parent_hwnd)
-      : plugin_(plugin),
+                             gfx::NativeWindow parent_wnd)
+      : main_message_loop_(main_message_loop),
+        io_message_loop_(MessageLoop::current()),
+        plugin_(plugin),
         plugin_context_(plugin_context),
-        main_message_loop_(main_message_loop),
-        io_message_loop_(MessageLoop::current()),
-        parent_hwnd_(parent_hwnd) {
+        parent_wnd_(parent_wnd) {
     DCHECK(ChromePluginLib::IsPluginThread());
     params_.url = url;
     params_.height = height;
     params_.width = width;
     params_.json_input = json_arguments;
 
     main_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
         this, &ModelessHtmlDialogDelegate::Show));
   }
   ~ModelessHtmlDialogDelegate() {
     DCHECK(ChromePluginLib::IsPluginThread());
   }
 
   // The following public methods are called from the UI thread.
 
   // HtmlDialogContentsDelegate implementation:
   virtual bool IsDialogModal() const { return false; }
   virtual std::wstring GetDialogTitle() const { return L"Google Gears"; }
   virtual GURL GetDialogContentURL() const { return params_.url; }
-  virtual void GetDialogSize(CSize* size) const {
-    size->cx = params_.width;
-    size->cy = params_.height;
+  virtual void GetDialogSize(gfx::Size* size) const {
+    size->set_width(params_.width);
+    size->set_height(params_.height);
   }
   virtual std::string GetDialogArgs() const { return params_.json_input; }
   virtual void OnDialogClosed(const std::string& json_retval) {
     io_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
         this, &ModelessHtmlDialogDelegate::ReportResults, json_retval));
   }
 
  private:
   // Actually shows the dialog on the UI thread.
   void Show() {
     DCHECK(MessageLoop::current() == main_message_loop_);
     Browser* browser = BrowserList::GetLastActive();
-    browser->ShowHtmlDialog(this, parent_hwnd_);
+    browser->ShowHtmlDialog(this, parent_wnd_);
   }
 
   // Gives the JSON result string back to the plugin.
   void ReportResults(const std::string& json_retval) {
     DCHECK(MessageLoop::current() == io_message_loop_);
     // The plugin may have unloaded before it was time to report the results.
     if (plugin_->is_loaded())
       plugin_->functions().html_dialog_closed(plugin_context_,
                                               json_retval.c_str());
     delete this;
   }
 
   // The parameters needed to display a modal HTML dialog.
   HtmlDialogContents::HtmlDialogParams params_;
 
   // Message loops for sending messages between UI and IO threads.
   MessageLoop* main_message_loop_;
   MessageLoop* io_message_loop_;
 
   // The plugin object that requested the dialog.  This can only be accessed on
   // the IO thread.
   scoped_refptr<ChromePluginLib> plugin_;
 
   // The plugin's context argument to CPB_ShowHtmlDialog.
   void* plugin_context_;
 
   // The window this dialog box should be parented to, or NULL for the last
   // active browser window.
-  HWND parent_hwnd_;
+  gfx::NativeWindow parent_wnd_;
 
   DISALLOW_EVIL_CONSTRUCTORS(ModelessHtmlDialogDelegate);
 };
 
 // Allows InvokeLater without adding refcounting.  The object is only deleted
 // when its last InvokeLater is run anyway.
+template<>
 void RunnableMethodTraits<ModelessHtmlDialogDelegate>::RetainCallee(
     ModelessHtmlDialogDelegate* remover) {
 }
+template<>
 void RunnableMethodTraits<ModelessHtmlDialogDelegate>::ReleaseCallee(
     ModelessHtmlDialogDelegate* remover) {
 }
 
 namespace {
 
 //
 // Generic functions
 //
 
@@ skipping 194 matching lines @@
 
 CPError STDCALL CPB_CreateRequest(CPID id, CPBrowsingContext context,
                                   const char* method, const char* url,
                                   CPRequest** request) {
   CHECK(ChromePluginLib::IsPluginThread());
   ChromePluginLib* plugin = ChromePluginLib::FromCPID(id);
   CHECK(plugin);
 
   ScopableCPRequest* cprequest = new ScopableCPRequest(url, method, context);
   PluginRequestHandler* handler = new PluginRequestHandler(plugin, cprequest);
+  CHECK(handler);
 
   *request = cprequest;
   return CPERR_SUCCESS;
 }
 
 CPError STDCALL CPR_StartRequest(CPRequest* request) {
   CHECK(ChromePluginLib::IsPluginThread());
   PluginRequestHandler* handler = PluginRequestHandler::FromCPRequest(request);
   CHECK(handler);
   handler->request()->Start();
@@ skipping 104 matching lines @@
     PluginService* service = PluginService::GetInstance();
     if (!service)
     return CPERR_FAILURE;
     PluginProcessHost *host =
     service->FindOrStartPluginProcess(plugin->filename(), std::string());
     if (!host)
     return CPERR_FAILURE;
 
     const unsigned char* data_ptr = static_cast<const unsigned char*>(data);
     std::vector<uint8> v(data_ptr, data_ptr + data_len);
+#if defined(OS_WIN)
     if (!host->Send(new PluginProcessMsg_PluginMessage(v)))
       return CPERR_FAILURE;
+#else
+    // TODO(port): Implement PluginProcessMsg.
+    NOTIMPLEMENTED();
+#endif
 
     return CPERR_SUCCESS;
   }
 }
 
 CPError STDCALL CPB_SendSyncMessage(CPID id, const void *data, uint32 data_len,
                                     void **retval, uint32 *retval_len) {
   NOTREACHED() << "Sync messages should not be sent from the browser process.";
 
   return CPERR_FAILURE;
@@ skipping 81 matching lines @@
 void CPHandleCommand(int command, CPCommandInterface* data,
                      CPBrowsingContext context) {
   // Sadly if we try and pass context through, we seem to break cl's little
   // brain trying to compile the Tuple3 ctor. This cast works.
   int32 context_as_int32 = static_cast<int32>(context);
   // Plugins can only be accessed on the IO thread.
   g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
       NewRunnableFunction(PluginCommandHandler::HandleCommand,
                           command, data, context_as_int32));
 }