Log when a browser plugin hangs

webkit/plugins/npapi/webplugin_delegate_impl_win.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 "webkit/plugins/npapi/webplugin_delegate_impl.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 30 matching lines @@
 using WebKit::WebInputEvent;
 using WebKit::WebMouseEvent;
 
 namespace webkit {
 namespace npapi {
 
 namespace {
 
 const wchar_t kWebPluginDelegateProperty[] = L"WebPluginDelegateProperty";
 const wchar_t kPluginNameAtomProperty[] = L"PluginNameAtom";
+const wchar_t kPluginVersionAtomProperty[] = L"PluginVersionAtom";
 const wchar_t kDummyActivationWindowName[] = L"DummyWindowForActivation";
 const wchar_t kPluginFlashThrottle[] = L"FlashThrottle";
 
 // The fastest we are willing to process WM_USER+1 events for Flash.
 // Flash can easily exceed the limits of our CPU if we don't throttle it.
 // The throttle has been chosen by testing various delays and compromising
 // on acceptable Flash performance and reasonable CPU consumption.
 //
 // I'd like to make the throttle delay variable, based on the amount of
 // time currently required to paint Flash plugins.  There isn't a good
@@ skipping 195 matching lines @@
 int GetPluginMajorVersion(const WebPluginInfo& plugin_info) {
   scoped_ptr<Version> plugin_version(PluginGroup::CreateVersionFromString(
       plugin_info.version));
   int major_version = 0;
   if (plugin_version.get()) {
     major_version = plugin_version->components()[0];
   }
   return major_version;
 }
 
+bool GetPluginPropertyFromWindow(
+    HWND window, const wchar_t* plugin_atom_property,
+    string16* plugin_property) {
+  ATOM plugin_atom = reinterpret_cast<ATOM>(
+      GetPropW(window, plugin_atom_property));
+  if (plugin_atom != 0) {
+    WCHAR plugin_property_local[MAX_PATH] = {0};
+    GlobalGetAtomNameW(plugin_atom,
+                       plugin_property_local,
+                       ARRAYSIZE(plugin_property_local));
+    *plugin_property = plugin_property_local;
+    return true;
+  }
+  return false;
+}
+
 }  // namespace
 
 bool WebPluginDelegateImpl::IsPluginDelegateWindow(HWND window) {
   static const int kBufLen = 64;
   wchar_t class_name[kBufLen];
   if (!GetClassNameW(window, class_name, kBufLen))
     return false;
   return wcscmp(class_name, kNativeWindowClassName) == 0;
 }
 
 // static
 bool WebPluginDelegateImpl::GetPluginNameFromWindow(
     HWND window, string16* plugin_name) {
-  if (NULL == plugin_name) {
-    return false;
-  }
-  if (!IsPluginDelegateWindow(window)) {
-    return false;
-  }
-  ATOM plugin_name_atom = reinterpret_cast<ATOM>(
-      GetPropW(window, kPluginNameAtomProperty));
-  if (plugin_name_atom != 0) {
-    WCHAR plugin_name_local[MAX_PATH] = {0};
-    GlobalGetAtomNameW(plugin_name_atom,
-                       plugin_name_local,
-                       ARRAYSIZE(plugin_name_local));
-    *plugin_name = plugin_name_local;
-    return true;
-  }
-  return false;
+  return IsPluginDelegateWindow(window) &&
+      GetPluginPropertyFromWindow(
+          window, kPluginNameAtomProperty, plugin_name);
+}
+
+// static
+bool WebPluginDelegateImpl::GetPluginVersionFromWindow(
+    HWND window, string16* plugin_version) {
+  return IsPluginDelegateWindow(window) &&
+      GetPluginPropertyFromWindow(
+          window, kPluginVersionAtomProperty, plugin_version);
 }
 
 bool WebPluginDelegateImpl::IsDummyActivationWindow(HWND window) {
   if (!IsWindow(window))
     return false;
 
   wchar_t window_title[MAX_PATH + 1] = {0};
   if (GetWindowText(window, window_title, arraysize(window_title))) {
     return (0 == lstrcmpiW(window_title, kDummyActivationWindowName));
   }
@@ skipping 382 matching lines @@
     // this window should be a child window of the parent window.
     // To satisfy both of the above conditions, this code once creates a
     // top-level window and change it to a child window of the parent window.
     SetWindowLongPtr(windowed_handle_, GWL_STYLE,
                      WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
     SetParent(windowed_handle_, parent_);
   }
 
   BOOL result = SetProp(windowed_handle_, kWebPluginDelegateProperty, this);
   DCHECK(result == TRUE) << "SetProp failed, last error = " << GetLastError();
-  // Get the name of the plugin, create an atom and set that in a window
-  // property. Use an atom so that other processes can access the name of
-  // the plugin that this window is hosting
+  // Get the name and version of the plugin, create atoms and set them in a
+  // window property. Use atoms so that other processes can access the name and
+  // version of the plugin that this window is hosting.
   if (instance_ != NULL) {
     PluginLib* plugin_lib = instance()->plugin_lib();
     if (plugin_lib != NULL) {
       std::wstring plugin_name = plugin_lib->plugin_info().name;
       if (!plugin_name.empty()) {
         ATOM plugin_name_atom = GlobalAddAtomW(plugin_name.c_str());
         DCHECK(0 != plugin_name_atom);
         result = SetProp(windowed_handle_,
             kPluginNameAtomProperty,
             reinterpret_cast<HANDLE>(plugin_name_atom));
         DCHECK(result == TRUE) << "SetProp failed, last error = " <<
             GetLastError();
       }
+      string16 plugin_version = plugin_lib->plugin_info().version;
+      if (!plugin_version.empty()) {
+        ATOM plugin_version_atom = GlobalAddAtomW(plugin_version.c_str());
+        DCHECK(0 != plugin_version_atom);
+        result = SetProp(windowed_handle_,
+            kPluginVersionAtomProperty,
+            reinterpret_cast<HANDLE>(plugin_version_atom));
+        DCHECK(result == TRUE) << "SetProp failed, last error = " <<
+            GetLastError();
+      }
     }
   }
 
   // Calling SetWindowLongPtrA here makes the window proc ASCII, which is
   // required by at least the Shockwave Director plug-in.
   SetWindowLongPtrA(
       windowed_handle_, GWL_WNDPROC, reinterpret_cast<LONG>(DefWindowProcA));
 
   return true;
 }
@@ skipping 476 matching lines @@
 
     delegate->is_calling_wndproc = false;
     g_current_plugin_instance = last_plugin_instance;
 
     if (message == WM_NCDESTROY) {
       RemoveProp(hwnd, kWebPluginDelegateProperty);
       ATOM plugin_name_atom = reinterpret_cast<ATOM>(
           RemoveProp(hwnd, kPluginNameAtomProperty));
       if (plugin_name_atom != 0)
         GlobalDeleteAtom(plugin_name_atom);
+      ATOM plugin_version_atom = reinterpret_cast<ATOM>(
+          RemoveProp(hwnd, kPluginVersionAtomProperty));
+      if (plugin_version_atom != 0)
+        GlobalDeleteAtom(plugin_version_atom);
       ClearThrottleQueueForWindow(hwnd);
     }
   }
   delegate->last_message_ = old_message;
   return result;
 }
 
 void WebPluginDelegateImpl::WindowlessUpdateGeometry(
     const gfx::Rect& window_rect,
     const gfx::Rect& clip_rect) {
@@ skipping 452 matching lines @@
       ::ReleaseCapture();
       break;
 
     default:
       break;
   }
 }
 
 }  // namespace npapi
 }  // namespace webkit