Log when a browser plugin hangs

chrome/browser/hang_monitor/hung_plugin_action.cc

 // Copyright (c) 2011 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 <windows.h>
 
 #include "chrome/browser/hang_monitor/hung_plugin_action.h"
 
+#include "base/metrics/histogram.h"
+#include "base/version.h"
 #include "chrome/browser/simple_message_box.h"
 #include "chrome/common/logging_chrome.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/win/hwnd_util.h"
+#include "webkit/plugins/npapi/plugin_group.h"
 #include "webkit/plugins/npapi/webplugin_delegate_impl.h"
 
+namespace {
+
+const wchar_t kGTalkPluginName[] = L"Google Talk Plugin";
+const int kMaxGTalkPluginVersion = 10000;
+
+// Converts the version string of Google Talk Plugin to a number. The
+// version format is "major(1 digit).minor(1 digit).sub(1 or 2 digits)",
+// for example, "2.7.10" and "2.8.1". Converts the string to a number as
+// 1000 * major + 100 * minor + sub.
+int GetGTalkPluginVersion(const string16& version) {
+  int gtalk_plugin_version = 0;
+  scoped_ptr<Version> plugin_version(
+      webkit::npapi::PluginGroup::CreateVersionFromString(version));
+  if (plugin_version.get() && plugin_version->components().size() >= 3) {
+    gtalk_plugin_version = plugin_version->components()[0] * 1000 +
+        plugin_version->components()[1] * 100 +
+        plugin_version->components()[2];
+    if (gtalk_plugin_version > kMaxGTalkPluginVersion) {
+      gtalk_plugin_version = kMaxGTalkPluginVersion;
+    }
+  }
+  return gtalk_plugin_version;
+}
+
+}  // namespace
+
 HungPluginAction::HungPluginAction() : current_hung_plugin_window_(NULL) {
 }
 
 HungPluginAction::~HungPluginAction() {
 }
 
 bool HungPluginAction::OnHungWindowDetected(HWND hung_window,
                                             HWND top_level_window,
                                             ActionOnHungWindow* action) {
   if (NULL == action) {
     return false;
   }
   if (!IsWindow(hung_window)) {
     return false;
   }
 
   bool continue_hang_detection = true;
 
   DWORD hung_window_process_id = 0;
   DWORD top_level_window_process_id = 0;
   GetWindowThreadProcessId(hung_window, &hung_window_process_id);
   GetWindowThreadProcessId(top_level_window, &top_level_window_process_id);
 
+  bool is_gtalk_plugin = false;
+  int gtalk_plugin_version = 0;
   *action = HungWindowNotification::HUNG_WINDOW_IGNORE;
   if (top_level_window_process_id != hung_window_process_id) {
+    string16 plugin_name;
+    string16 plugin_version;
+    GetPluginNameAndVersion(hung_window,
+                            top_level_window_process_id,
+                            &plugin_name,
+                            &plugin_version);
+    if (plugin_name.empty()) {
+      plugin_name = l10n_util::GetStringUTF16(IDS_UNKNOWN_PLUGIN_NAME);
+    }
+
+    is_gtalk_plugin = (kGTalkPluginName == plugin_name);
+    if (is_gtalk_plugin) {
+      gtalk_plugin_version = GetGTalkPluginVersion(plugin_version);
+    }
+
     if (logging::DialogsAreSuppressed()) {
       NOTREACHED() << "Terminated a hung plugin process.";
       *action = HungWindowNotification::HUNG_WINDOW_TERMINATE_PROCESS;
     } else {
-      string16 plugin_name;
-      GetPluginName(hung_window,
-                    top_level_window_process_id,
-                    &plugin_name);
-      if (plugin_name.empty()) {
-        plugin_name = l10n_util::GetStringUTF16(IDS_UNKNOWN_PLUGIN_NAME);
-      }
       string16 msg = l10n_util::GetStringFUTF16(IDS_BROWSER_HANGMONITOR,
                                                 plugin_name);
       string16 title = l10n_util::GetStringUTF16(IDS_BROWSER_HANGMONITOR_TITLE);
       // Before displaying the message box, invoke SendMessageCallback on the
       // hung window. If the callback ever hits, the window is not hung anymore
       // and we can dismiss the message box.
       SendMessageCallback(hung_window,
                           WM_NULL,
                           0,
                           0,
@@ skipping 22 matching lines @@
 #pragma warning(default:4312)
         }
       }
       current_hung_plugin_window_ = NULL;
     }
   }
   if (HungWindowNotification::HUNG_WINDOW_TERMINATE_PROCESS == *action) {
     // Enable the top-level window just in case the plugin had been
     // displaying a modal box that had disabled the top-level window
     EnableWindow(top_level_window, TRUE);
+
+    UMA_HISTOGRAM_COUNTS("Plugin.Hung_Terminate_Process", 1);
+    if (is_gtalk_plugin) {
+      UMA_HISTOGRAM_ENUMERATION("GTalkPlugin.Hung_Terminate_Process",

[jar (doing other things), 2012/04/03 19:20:39]

We don't have a sparse histogram, and so the cost (in memory) of this histogram
will be very large.  With about 4 bytes per bucket for the sample counts, and 4
bytes per bucket for the ranges, this totals 80KB.  In addition, the snapshot of
each upload will cost about 40KB, for a grand total of 120KB of data space.

Until we have a slow/sparse histogram implemented, I think you should avoid
using histograms in this way.

We do  send up a list of plugins (and versions), but historically we did that
only in the initial log.  You could decide here that it was the GTalkPlugin, and
histogram failures, but leave it to secondary analysis to identify the cause. 
It is also possible that the newer proto-buf approach may include additional
plugin info in each log transmission... and that might make this a lot simpler. 
Perhaps we need to (at a minimum) upload version info for Google plugins all the
time, if you don't want to have to process this out after the fact.

+          gtalk_plugin_version, kMaxGTalkPluginVersion + 1);
+    }
+  } else {
+    UMA_HISTOGRAM_COUNTS("Plugin.Hung_Ignore", 1);
+    if (is_gtalk_plugin) {
+      UMA_HISTOGRAM_ENUMERATION("GTalkPlugin.Hung_Ignore",
+          gtalk_plugin_version, kMaxGTalkPluginVersion + 1);

[jar (doing other things), 2012/04/03 19:20:39]

This would be another 120KB :-/.

+    }
   }
   return continue_hang_detection;
 }
 
 void HungPluginAction::OnWindowResponsive(HWND window) {
   if (window == current_hung_plugin_window_) {
     // The message timeout for this window should fallback to the default
     // timeout as this window is now responsive.
     RemoveProp(window, HungWindowDetector::kHungChildWindowTimeout);
     // The monitored plugin recovered. Let's dismiss the message box.
     EnumThreadWindows(GetCurrentThreadId(),
                       reinterpret_cast<WNDENUMPROC>(DismissMessageBox),
                       NULL);
   }
 }
 
-bool HungPluginAction::GetPluginName(HWND plugin_window,
-                                     DWORD browser_process_id,
-                                     std::wstring* plugin_name) {
+bool HungPluginAction::GetPluginNameAndVersion(HWND plugin_window,
+                                               DWORD browser_process_id,
+                                               std::wstring* plugin_name,
+                                               std::wstring* plugin_version) {
   DCHECK(plugin_name);
+  DCHECK(plugin_version);
   HWND window_to_check = plugin_window;
   while (NULL != window_to_check) {
     DWORD process_id = 0;
     GetWindowThreadProcessId(window_to_check, &process_id);
     if (process_id == browser_process_id) {
       // If we have reached a window the that belongs to the browser process
       // we have gone too far.
       return false;
     }
     if (webkit::npapi::WebPluginDelegateImpl::GetPluginNameFromWindow(
             window_to_check, plugin_name)) {
+      webkit::npapi::WebPluginDelegateImpl::GetPluginVersionFromWindow(
+          window_to_check, plugin_version);
       return true;
     }
     window_to_check = GetParent(window_to_check);
   }
   return false;
 }
 
 // static
 BOOL CALLBACK HungPluginAction::DismissMessageBox(HWND window, LPARAM ignore) {
   string16 class_name = ui::GetClassName(window);
@@ skipping 10 matching lines @@
 void CALLBACK HungPluginAction::HungWindowResponseCallback(HWND target_window,
                                                            UINT message,
                                                            ULONG_PTR data,
                                                            LRESULT result) {
   HungPluginAction* instance = reinterpret_cast<HungPluginAction*>(data);
   DCHECK(NULL != instance);
   if (NULL != instance) {
     instance->OnWindowResponsive(target_window);
   }
 }