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

chrome/renderer/webplugin_delegate_proxy.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/renderer/webplugin_delegate_proxy.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <atlbase.h>
@@ skipping 140 matching lines @@
   int instance_id_;
   int resource_id_;
   GURL url_;
   bool notify_needed_;
   intptr_t notify_data_;
   // Set to true if the response expected is a multibyte response.
   // For e.g. response for a HTTP byte range request.
   bool multibyte_response_expected_;
 };
 
-WebPluginDelegateProxy* WebPluginDelegateProxy::Create(
-    const GURL& url,
-    const std::string& mime_type,
-    const std::string& clsid,
-    const base::WeakPtr<RenderView>& render_view) {
-  return new WebPluginDelegateProxy(mime_type, clsid, render_view);
-}
-
 WebPluginDelegateProxy::WebPluginDelegateProxy(
     const std::string& mime_type,
     const std::string& clsid,
     const base::WeakPtr<RenderView>& render_view)
     : render_view_(render_view),
       plugin_(NULL),
       windowless_(false),
       window_(NULL),
       mime_type_(mime_type),
       clsid_(clsid),
@@ skipping 39 matching lines @@
     // Destroying the channel host is what releases the channel name -> FD
     // association on POSIX, and if we ask for a new connection before it is
     // released, the plugin will give us a new FD, and we'll assert when trying
     // to associate it with the channel name.
     channel_host_ = NULL;
   }
 
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
-bool WebPluginDelegateProxy::Initialize(const GURL& url, char** argn,
-                                        char** argv, int argc,
+bool WebPluginDelegateProxy::Initialize(const GURL& url,
+                                        const std::vector<std::string>& arg_names,
+                                        const std::vector<std::string>& arg_values,
                                         webkit_glue::WebPlugin* plugin,
                                         bool load_manually) {
   IPC::ChannelHandle channel_handle;
-  FilePath plugin_path;
+  WebPluginInfo info;
   if (!RenderThread::current()->Send(new ViewHostMsg_OpenChannelToPlugin(
           url, mime_type_, clsid_, webkit_glue::GetWebKitLocale(),
-          &channel_handle, &plugin_path))) {
+          &channel_handle, &info))) {
     return false;
   }
 
 #if defined(OS_POSIX)
   if (channel_handle.name.empty()) {
     // We got an invalid handle. Possibly the plugin process is stale? In any
     // case, don't try to connect to it, the empty name represents the host
     // channel, and connecting to it again does bad things.
     return false;
   }
 
   // If we received a ChannelHandle, register it now.
   if (channel_handle.socket.fd >= 0)
     IPC::AddChannelSocket(channel_handle.name, channel_handle.socket.fd);
 #endif
 
   scoped_refptr<PluginChannelHost> channel_host =
       PluginChannelHost::GetPluginChannelHost(
           channel_handle.name, ChildProcess::current()->io_message_loop());
   if (!channel_host.get())
     return false;
 
   int instance_id;
   bool result = channel_host->Send(new PluginMsg_CreateInstance(
       mime_type_, &instance_id));
   if (!result)
     return false;
 
-  plugin_path_ = plugin_path;
+  info_ = info;
   channel_host_ = channel_host;
   instance_id_ = instance_id;
 
   channel_host_->AddRoute(instance_id_, this, false);
 
   // Now tell the PluginInstance in the plugin process to initialize.
   PluginMsg_Init_Params params;
   params.containing_window = render_view_->host_window();
   params.url = url;
   params.page_url = page_url_;
-  for (int i = 0; i < argc; ++i) {
-    params.arg_names.push_back(argn[i]);
-    params.arg_values.push_back(argv[i]);
-
-    if (LowerCaseEqualsASCII(params.arg_names.back(), "wmode") &&
-        LowerCaseEqualsASCII(params.arg_values.back(), "transparent")) {
+  params.arg_names = arg_names;
+  params.arg_values = arg_values;
+  for (size_t i = 0; i < arg_names.size(); ++i) {
+    if (LowerCaseEqualsASCII(arg_names[i], "wmode") &&
+        LowerCaseEqualsASCII(arg_values[i], "transparent")) {
       transparent_ = true;
     }
   }
   params.load_manually = load_manually;
 #if defined(OS_WIN)
   params.modal_dialog_event = render_view_->modal_dialog_event()->handle();
 #endif
 
   plugin_ = plugin;
 
@@ skipping 49 matching lines @@
 }
 
 void WebPluginDelegateProxy::DidFinishManualLoading() {
   Send(new PluginMsg_DidFinishManualLoading(instance_id_));
 }
 
 void WebPluginDelegateProxy::DidManualLoadFail() {
   Send(new PluginMsg_DidManualLoadFail(instance_id_));
 }
 
-FilePath WebPluginDelegateProxy::GetPluginPath() {
-  return plugin_path_;
-}
-
 void WebPluginDelegateProxy::InstallMissingPlugin() {
   Send(new PluginMsg_InstallMissingPlugin(instance_id_));
 }
 
 void WebPluginDelegateProxy::OnMessageReceived(const IPC::Message& msg) {
   child_process_logging::ScopedActiveURLSetter url_setter(page_url_);
 
   IPC_BEGIN_MESSAGE_MAP(WebPluginDelegateProxy, msg)
     IPC_MESSAGE_HANDLER(PluginHostMsg_SetWindow, OnSetWindow)
 #if defined(OS_WIN)
@@ skipping 28 matching lines @@
 
 void WebPluginDelegateProxy::OnChannelError() {
   if (plugin_) {
     if (window_) {
       // The actual WebPluginDelegate never got a chance to tell the WebPlugin
       // its window was going away. Do it on its behalf.
       WillDestroyWindow();
     }
     plugin_->Invalidate();
   }
-  render_view_->PluginCrashed(GetProcessId(), plugin_path_);
+  render_view_->PluginCrashed(GetProcessId(), info_.path);
 }
 
 void WebPluginDelegateProxy::UpdateGeometry(const gfx::Rect& window_rect,
                                             const gfx::Rect& clip_rect) {
   plugin_rect_ = window_rect;
 
   bool bitmaps_changed = false;
 
   if (windowless_) {
     if (!backing_store_canvas_.get() ||
         (window_rect.width() != backing_store_canvas_->getDevice()->width() ||
          window_rect.height() != backing_store_canvas_->getDevice()->height())) {
       bitmaps_changed = true;
       // Create a shared memory section that the plugin paints into
       // asynchronously.
       ResetWindowlessBitmaps();
       if (!window_rect.IsEmpty()) {
         if (!CreateBitmap(&backing_store_, &backing_store_canvas_) ||
             !CreateBitmap(&transport_store_, &transport_store_canvas_) ||
             (transparent_ &&
              !CreateBitmap(&background_store_, &background_store_canvas_))) {
           DCHECK(false);
           ResetWindowlessBitmaps();
           return;
         }
       }
     }
   }
 
-  IPC::Message* msg = NULL;
+  PluginMsg_UpdateGeometry_Param param;
+  param.window_rect = window_rect;
+  param.clip_rect = clip_rect;
+  param.windowless_buffer = TransportDIB::DefaultHandleValue();
+  param.background_buffer = TransportDIB::DefaultHandleValue();
+
 #if defined(OS_POSIX)
   // If we're using POSIX mmap'd TransportDIBs, sending the handle across
   // IPC establishes a new mapping rather than just sending a window ID,
   // so only do so if we've actually recreated the shared memory bitmaps.
-  if (!bitmaps_changed) {
-    msg = new PluginMsg_UpdateGeometry(instance_id_, window_rect, clip_rect,
-        TransportDIB::DefaultHandleValue(), TransportDIB::DefaultHandleValue());
+  if (bitmaps_changed)
+#endif
+  {
+    if (transport_store_.get()) {
+      param.windowless_buffer = transport_store_->handle();
+    } else if (background_store_.get()) {
+      param.background_buffer = background_store_->handle();
+    }
+  }
+
+ IPC::Message* msg;
+#if defined (OS_WIN)
+  std::wstring filename = StringToLowerASCII(info_.path.BaseName().value());
+  if (info_.name.find(L"Windows Media Player") != std::wstring::npos) {
+    // Need to update geometry synchronously with WMP, otherwise if a site
+    // scripts the plugin to start playing while it's in the middle of handling
+    // an update geometry message, videos don't play.  See urls in bug 20260.
+    msg = new PluginMsg_UpdateGeometrySync(instance_id_, param);
   } else
 #endif
-  if (transport_store_.get() && background_store_.get()) {
-    msg = new PluginMsg_UpdateGeometry(instance_id_, window_rect, clip_rect,
-        transport_store_->handle(), background_store_->handle());
-  } else if (transport_store_.get()) {
-    msg = new PluginMsg_UpdateGeometry(instance_id_, window_rect, clip_rect,
-        transport_store_->handle(), TransportDIB::DefaultHandleValue());
-  } else {
-    msg = new PluginMsg_UpdateGeometry(instance_id_, window_rect, clip_rect,
-        TransportDIB::DefaultHandleValue(), TransportDIB::DefaultHandleValue());
+  {
+    msg = new PluginMsg_UpdateGeometry(instance_id_, param);
+    msg->set_unblock(true);
   }
 
-  msg->set_unblock(true);
   Send(msg);
 }
 
 #if defined(OS_MACOSX)
 static void ReleaseTransportDIB(TransportDIB *dib) {
   if (dib) {
     IPC::Message* msg = new ViewHostMsg_FreeTransportDIB(dib->id());
     RenderThread::current()->Send(msg);
   }
 }
@@ skipping 587 matching lines @@
 webkit_glue::WebPluginResourceClient*
 WebPluginDelegateProxy::CreateResourceClient(
     int resource_id, const GURL& url, bool notify_needed,
     intptr_t notify_data, intptr_t npstream) {
   ResourceClientProxy* proxy = new ResourceClientProxy(channel_host_,
                                                        instance_id_);
   proxy->Initialize(resource_id, url, notify_needed, notify_data, npstream);
   return proxy;
 }
 
-bool WebPluginDelegateProxy::IsWindowless() const {
-  NOTREACHED();
-  return false;
-}
-
-gfx::Rect WebPluginDelegateProxy::GetRect() const {
-  NOTREACHED();
-  return gfx::Rect();
-}
-
-gfx::Rect WebPluginDelegateProxy::GetClipRect() const {
-  NOTREACHED();
-  return gfx::Rect();
-}
-
-int WebPluginDelegateProxy::GetQuirks() const {
-  NOTREACHED();
-  return 0;
-}
-
 void WebPluginDelegateProxy::OnCancelDocumentLoad() {
   plugin_->CancelDocumentLoad();
 }
 
 void WebPluginDelegateProxy::OnInitiateHTTPRangeRequest(
     const std::string& url, const std::string& range_info,
     intptr_t existing_stream, bool notify_needed, intptr_t notify_data) {
   plugin_->InitiateHTTPRangeRequest(url.c_str(), range_info.c_str(),
                                     existing_stream, notify_needed,
                                     notify_data);
 }
 
 void WebPluginDelegateProxy::OnDeferResourceLoading(int resource_id,
                                                     bool defer) {
   plugin_->SetDeferResourceLoading(resource_id, defer);
 }