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",
+          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);
+    }
   }
   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);
   }
 }