This changelist fixes some issues with the NPAPI WMP plugin work in Chrome. ...

chrome/plugin/webplugin_delegate_stub.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/plugin/webplugin_delegate_stub.h"
 
 #include "build/build_config.h"
 
 #include "base/command_line.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/plugin_messages.h"
 #include "chrome/plugin/npobject_stub.h"
 #include "chrome/plugin/plugin_channel.h"
 #include "chrome/plugin/plugin_thread.h"
 #include "chrome/plugin/webplugin_proxy.h"
 #include "printing/native_metafile.h"
 #include "third_party/npapi/bindings/npapi.h"
 #include "third_party/npapi/bindings/npruntime.h"
 #include "skia/ext/platform_device.h"
 #include "webkit/api/public/WebBindings.h"
 #include "webkit/api/public/WebCursorInfo.h"
+#include "webkit/glue/plugins/webplugin_delegate_impl.h"
 #include "webkit/glue/webcursor.h"
-#include "webkit/glue/webplugin_delegate.h"
 
 using WebKit::WebBindings;
 using WebKit::WebCursorInfo;
 using webkit_glue::WebPlugin;
-using webkit_glue::WebPluginDelegate;
 using webkit_glue::WebPluginResourceClient;
 
 class FinishDestructionTask : public Task {
  public:
-  FinishDestructionTask(WebPluginDelegate* delegate, WebPlugin* webplugin)
+  FinishDestructionTask(WebPluginDelegateImpl* delegate, WebPlugin* webplugin)
     : delegate_(delegate), webplugin_(webplugin) { }
 
   void Run() {
     // WebPlugin must outlive WebPluginDelegate.
     if (delegate_)
       delegate_->PluginDestroyed();
 
     delete webplugin_;
   }
 
  private:
-  WebPluginDelegate* delegate_;
+  WebPluginDelegateImpl* delegate_;
   WebPlugin* webplugin_;
 };
 
 WebPluginDelegateStub::WebPluginDelegateStub(
     const std::string& mime_type, int instance_id, PluginChannel* channel) :
     mime_type_(mime_type),
     instance_id_(instance_id),
     channel_(channel),
     delegate_(NULL),
     webplugin_(NULL) {
@@ skipping 35 matching lines @@
     IPC_MESSAGE_HANDLER(PluginMsg_DidFinishLoadWithReason,
                         OnDidFinishLoadWithReason)
     IPC_MESSAGE_HANDLER(PluginMsg_SetFocus, OnSetFocus)
     IPC_MESSAGE_HANDLER(PluginMsg_HandleInputEvent, OnHandleInputEvent)
     IPC_MESSAGE_HANDLER(PluginMsg_Paint, OnPaint)
     IPC_MESSAGE_HANDLER(PluginMsg_DidPaint, OnDidPaint)
     IPC_MESSAGE_HANDLER(PluginMsg_Print, OnPrint)
     IPC_MESSAGE_HANDLER(PluginMsg_GetPluginScriptableObject,
                         OnGetPluginScriptableObject)
     IPC_MESSAGE_HANDLER(PluginMsg_UpdateGeometry, OnUpdateGeometry)
+    IPC_MESSAGE_HANDLER(PluginMsg_UpdateGeometrySync, OnUpdateGeometry)
     IPC_MESSAGE_HANDLER(PluginMsg_SendJavaScriptStream,
                         OnSendJavaScriptStream)
     IPC_MESSAGE_HANDLER(PluginMsg_DidReceiveManualResponse,
                         OnDidReceiveManualResponse)
     IPC_MESSAGE_HANDLER(PluginMsg_DidReceiveManualData, OnDidReceiveManualData)
     IPC_MESSAGE_HANDLER(PluginMsg_DidFinishManualLoading,
                         OnDidFinishManualLoading)
     IPC_MESSAGE_HANDLER(PluginMsg_DidManualLoadFail, OnDidManualLoadFail)
     IPC_MESSAGE_HANDLER(PluginMsg_InstallMissingPlugin, OnInstallMissingPlugin)
     IPC_MESSAGE_HANDLER(PluginMsg_HandleURLRequestReply,
                         OnHandleURLRequestReply)
     IPC_MESSAGE_UNHANDLED_ERROR()
   IPC_END_MESSAGE_MAP()
 
   Release();
 }
 
 bool WebPluginDelegateStub::Send(IPC::Message* msg) {
   return channel_->Send(msg);
 }
 
 void WebPluginDelegateStub::OnInit(const PluginMsg_Init_Params& params,
                                    bool* result) {
   page_url_ = params.page_url;
   child_process_logging::ScopedActiveURLSetter url_setter(page_url_);
 
   *result = false;
-  int argc = static_cast<int>(params.arg_names.size());
-  if (argc != static_cast<int>(params.arg_values.size())) {
+  if (params.arg_names.size() != params.arg_values.size()) {
     NOTREACHED();
     return;
   }
 
-  char **argn = new char*[argc];
-  char **argv = new char*[argc];
-  for (int i = 0; i < argc; ++i) {
-    argn[i] = const_cast<char*>(params.arg_names[i].c_str());
-    argv[i] = const_cast<char*>(params.arg_values[i].c_str());
-  }
-
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   FilePath path = FilePath::FromWStringHack(
       command_line.GetSwitchValue(switches::kPluginPath));
 
 
   gfx::PluginWindowHandle parent = NULL;
 #if defined(OS_WIN)
   parent = gfx::NativeViewFromId(params.containing_window);
 #elif defined(OS_LINUX)
   // This code is disabled, See issue 17110.
   // The problem is that the XID can change at arbitrary times (e.g. when the
   // tab is detached then reattached), so we need to be able to track these
   // changes, and let the PluginInstance know.
   // PluginThread::current()->Send(new PluginProcessHostMsg_MapNativeViewId(
   //    params.containing_window, &parent));
 #endif
 
   webplugin_ = new WebPluginProxy(channel_, instance_id_, page_url_);
 #if defined(OS_WIN)
   if (!webplugin_->SetModalDialogEvent(params.modal_dialog_event))
     return;
 #endif
 
-  delegate_ = WebPluginDelegate::Create(path, mime_type_, parent);
+  delegate_ = WebPluginDelegateImpl::Create(path, mime_type_, parent);
   if (delegate_) {
     webplugin_->set_delegate(delegate_);
-    *result = delegate_->Initialize(
-        params.url, argn, argv, argc, webplugin_, params.load_manually);
+    *result = delegate_->Initialize(params.url,
+                                    params.arg_names,
+                                    params.arg_values,
+                                    webplugin_,
+                                    params.load_manually);
   }
-
-  delete[] argn;
-  delete[] argv;
 }
 
 void WebPluginDelegateStub::OnWillSendRequest(int id, const GURL& url) {
   WebPluginResourceClient* client = webplugin_->GetResourceClient(id);
   if (!client)
     return;
 
   client->WillSendRequest(url);
 }
 
@@ skipping 87 matching lines @@
   // Retrieve a copy of the data.
   bool success = metafile.GetData(shared_buf.memory(), *size);
   DCHECK(success);
 #else
   // TODO(port): plugin printing.
   NOTIMPLEMENTED();
 #endif
 }
 
 void WebPluginDelegateStub::OnUpdateGeometry(
-    const gfx::Rect& window_rect,
-    const gfx::Rect& clip_rect,
-    const TransportDIB::Handle& windowless_buffer,
-    const TransportDIB::Handle& background_buffer) {
+    const PluginMsg_UpdateGeometry_Param& param) {
   webplugin_->UpdateGeometry(
-      window_rect, clip_rect,
-      windowless_buffer, background_buffer);
+      param.window_rect, param.clip_rect,
+      param.windowless_buffer, param.background_buffer);
 }
 
 void WebPluginDelegateStub::OnGetPluginScriptableObject(int* route_id,
                                                         intptr_t* npobject_ptr) {
   NPObject* object = delegate_->GetPluginScriptableObject();
   if (!object) {
     *route_id = MSG_ROUTING_NONE;
     return;
   }
 
@@ skipping 77 matching lines @@
 
 void WebPluginDelegateStub::OnHandleURLRequestReply(
     const PluginMsg_URLRequestReply_Params& params) {
   WebPluginResourceClient* resource_client =
       delegate_->CreateResourceClient(params.resource_id, params.url,
                                       params.notify_needed,
                                       params.notify_data,
                                       params.stream);
   webplugin_->OnResourceCreated(params.resource_id, resource_client);
 }