Fix painting glitch with text and NPAPI plugins. This was a regression from r167042. The problem wa…

content/renderer/webplugin_delegate_proxy.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 "content/renderer/webplugin_delegate_proxy.h"
 
 #if defined(TOOLKIT_GTK)
 #include <gtk/gtk.h>
 #elif defined(USE_X11)
 #include <cairo/cairo.h>
@@ skipping 177 matching lines @@
 
  private:
   scoped_refptr<PluginChannelHost> channel_;
   int instance_id_;
   unsigned long resource_id_;
   // 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_;
 };
 
+// Returns true if the given Silverlight 'background' value corresponds to
+// one that should make the plugin transparent. See:
+// http://msdn.microsoft.com/en-us/library/cc838148(VS.95).aspx
+// for possible values.
+static bool SilverlightColorIsTransparent(const std::string& color) {
+  if (StartsWithASCII(color, "#", false)) {
+    // If it's #ARGB or #AARRGGBB check the alpha; if not it's an RGB form and
+    // it's not transparent.
+    if ((color.length() == 5 && !StartsWithASCII(color, "#F", false)) ||
+        (color.length() == 9 && !StartsWithASCII(color, "#FF", false)))
+      return true;
+  } else if (StartsWithASCII(color, "sc#", false)) {
+    // It's either sc#A,R,G,B or sc#R,G,B; if the former, check the alpha.
+    if (color.length() < 4)
+      return false;
+    std::string value_string = color.substr(3, std::string::npos);
+    std::vector<std::string> components;
+    base::SplitString(value_string, ',', &components);
+    if (components.size() == 4 && !StartsWithASCII(components[0], "1", false))
+      return true;
+  } else if (LowerCaseEqualsASCII(color, "transparent")) {
+    return true;
+  }
+  // Anything else is a named, opaque color or an RGB form with no alpha.
+  return false;
+}
+
 }  // namespace
 
 WebPluginDelegateProxy::WebPluginDelegateProxy(
     const std::string& mime_type,
     const base::WeakPtr<RenderViewImpl>& render_view)
     : render_view_(render_view),
       plugin_(NULL),
       uses_shared_bitmaps_(false),
 #if defined(OS_MACOSX)
       uses_compositor_(false),
 #elif defined(OS_WIN)
       dummy_activation_window_(NULL),
 #endif
       window_(gfx::kNullPluginWindow),
       mime_type_(mime_type),
       instance_id_(MSG_ROUTING_NONE),
       npobject_(NULL),
       sad_plugin_(NULL),
       invalidate_pending_(false),
+      transparent_(false),
       front_buffer_index_(0),
       page_url_(render_view_->webview()->mainFrame()->document().url()) {
 }
 
 WebPluginDelegateProxy::~WebPluginDelegateProxy() {
   if (npobject_)
     WebBindings::releaseObject(npobject_);
 }
 
 WebPluginDelegateProxy::SharedBitmap::SharedBitmap() {}
@@ skipping 138 matching lines @@
   PluginMsg_Init_Params params;
   params.url = url;
   params.page_url = page_url_;
   params.arg_names = arg_names;
   params.arg_values = arg_values;
   params.host_render_view_routing_id = render_view_->routing_id();
   params.load_manually = load_manually;
 
   plugin_ = plugin;
 
+  bool flash = LowerCaseEqualsASCII(mime_type_, kFlashPluginSwfMimeType);
+  bool silverlight =
+      StartsWithASCII(mime_type_, "application/x-silverlight", false);
+  for (size_t i = 0; i < arg_names.size(); ++i) {
+    if ((flash && LowerCaseEqualsASCII(arg_names[i], "wmode") &&
+        LowerCaseEqualsASCII(arg_values[i], "transparent")) ||
+        (silverlight && LowerCaseEqualsASCII(arg_names[i], "background") &&
+         SilverlightColorIsTransparent(arg_values[i]))) {
+      transparent_ = true;
+    }
+  }

[piman, 2013/03/06 00:58:57]

Do we really need all that logic? The plugin should already tell us if it's
transparent or opaque, by calling NPN_SetValue(_, NPPVpluginTransparentBool, _)
- see webkit/plugins/npapi/plugin_host.cc . Could we pipe that to the renderer?

[jam, 2013/03/06 01:58:36]

good point, switched to it.

we used to default to windowless being transparent, and now I've changed that. 
seems low risk since we didn't use that flag elsewhere, and the current change
is basically a no-op if NPN_SetValue isn't called.

+
   result = false;
   Send(new PluginMsg_Init(instance_id_, params, &result));
 
   if (!result)
     LOG(ERROR) << "PluginMsg_Init returned false";
 
   render_view_->RegisterPluginDelegate(this);
 
   return result;
 }
@@ skipping 333 matching lines @@
     // a chance that it will begin repainting the back-buffer before we complete
     // capturing the data. Buffer flipping would increase that risk because
     // geometry update is asynchronous, so we don't want to use buffer flipping
     // here.
     UpdateFrontBuffer(offset_rect, false);
   }
 
   const SkBitmap& bitmap =
       front_buffer_canvas()->getDevice()->accessBitmap(false);
   SkPaint paint;
-  paint.setXfermodeMode(SkXfermode::kSrcATop_Mode);
+  paint.setXfermodeMode(
+      transparent_ ? SkXfermode::kSrcATop_Mode : SkXfermode::kSrc_Mode);
   SkIRect src_rect = gfx::RectToSkIRect(offset_rect);
   canvas->drawBitmapRect(bitmap,
                          &src_rect,
                          gfx::RectToSkRect(rect),
                          &paint);
 
   if (invalidate_pending_) {
     // Only send the PaintAck message if this paint is in response to an
     // invalidate from the plugin, since this message acts as an access token
     // to ensure only one process is using the transport dib at a time.
@@ skipping 566 matching lines @@
 
 void WebPluginDelegateProxy::OnURLRedirectResponse(bool allow,
                                                    int resource_id) {
   if (!plugin_)
     return;
 
   plugin_->URLRedirectResponse(allow, resource_id);
 }
 
 }  // namespace content