Start and stop crash reporting outside of the loader lock.

chrome_frame/chrome_tab.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.
 
 // chrome_tab.cc : Implementation of DLL Exports.
 
 // Need to include this before the ATL headers below.
 #include "chrome_frame/chrome_tab.h"
 
 #include <atlsecurity.h>
 #include <objbase.h>
 
 #include "base/at_exit.h"
+#include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/logging.h"
 #include "base/logging_win.h"
 #include "base/metrics/field_trial.h"
 #include "base/path_service.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
@@ skipping 17 matching lines @@
 #include "chrome_frame/exception_barrier.h"
 #include "chrome_frame/metrics_service.h"
 #include "chrome_frame/resource.h"
 #include "chrome_frame/utils.h"
 #include "googleurl/src/url_util.h"
 #include "grit/chrome_frame_resources.h"
 
 using base::win::RegKey;
 
 namespace {
-// This function has the side effect of initializing an unprotected
-// vector pointer inside GoogleUrl. If this is called during DLL loading,
-// it has the effect of avoiding an initialization race on that pointer.
-// TODO(siggi): fix GoogleUrl.
-void InitGoogleUrl() {
-  static const char kDummyUrl[] = "http://www.google.com";
-
-  url_util::IsStandard(kDummyUrl,
-                       url_parse::MakeRange(0, arraysize(kDummyUrl)));
-}
 
 const wchar_t kInternetSettings[] =
     L"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings";
 
 const wchar_t kProtocolHandlers[] =
     L"Software\\Classes\\Protocols\\Handler";
 
 const wchar_t kRunOnce[] =
     L"Software\\Microsoft\\Windows\\CurrentVersion\\RunOnce";
 
 const wchar_t kRunKeyName[] = L"ChromeFrameHelper";
 
 const wchar_t kChromeFrameHelperExe[] = L"chrome_frame_helper.exe";
 const wchar_t kChromeFrameHelperStartupArg[] = L"--startup";
 
 // Window class and window names.
 // TODO(robertshield): These and other constants need to be refactored into
 // a common chrome_frame_constants.h|cc and built into a separate lib
 // (either chrome_frame_utils or make another one).
 const wchar_t kChromeFrameHelperWindowClassName[] =
     L"ChromeFrameHelperWindowClass";
 const wchar_t kChromeFrameHelperWindowName[] =
     L"ChromeFrameHelperWindowName";
 
 // {0562BFC3-2550-45b4-BD8E-A310583D3A6F}
-static const GUID kChromeFrameProvider =
+const GUID kChromeFrameProvider =
     { 0x562bfc3, 0x2550, 0x45b4,
         { 0xbd, 0x8e, 0xa3, 0x10, 0x58, 0x3d, 0x3a, 0x6f } };
 
 const wchar_t kPostPlatformUAKey[] =
     L"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\"
     L"User Agent\\Post Platform";
 const wchar_t kChromeFramePrefix[] = L"chromeframe/";
 
 // See comments in DllGetClassObject.
 LPFNGETCLASSOBJECT g_dll_get_class_object_redir_ptr = NULL;
 
+// This function has the side effect of initializing an unprotected
+// vector pointer inside GoogleUrl. If this is called during DLL loading,
+// it has the effect of avoiding an initialization race on that pointer.
+// TODO(siggi): fix GoogleUrl.
+void InitGoogleUrl() {
+  static const char kDummyUrl[] = "http://www.google.com";
+
+  url_util::IsStandard(kDummyUrl,
+                       url_parse::MakeRange(0, arraysize(kDummyUrl)));
+}
+
 class ChromeTabModule : public CAtlDllModuleT<ChromeTabModule> {
  public:
   typedef CAtlDllModuleT<ChromeTabModule> ParentClass;
 
-  ChromeTabModule() : do_system_registration_(true) {}
+  ChromeTabModule() : do_system_registration_(true), crash_reporting_(NULL) {}
 
   DECLARE_LIBID(LIBID_ChromeTabLib)
   DECLARE_REGISTRY_APPID_RESOURCEID(IDR_CHROMETAB,
                                     "{FD9B1B31-F4D8-436A-8F4F-D3C2E36733D3}")
 
   // Override to add our SYSTIME binary value to registry scripts.
   // See chrome_frame_activex.rgs for usage.
   virtual HRESULT AddCommonRGSReplacements(IRegistrarBase* registrar) throw() {
     HRESULT hr = ParentClass::AddCommonRGSReplacements(registrar);
 
@@ skipping 69 matching lines @@
     if (SUCCEEDED(hr)) {
       // Add the Chrome Frame CLSID.
       wchar_t cf_clsid[64];
       StringFromGUID2(CLSID_ChromeFrame, &cf_clsid[0], arraysize(cf_clsid));
       hr = registrar->AddReplacement(L"CHROME_FRAME_CLSID", &cf_clsid[0]);
     }
 
     return hr;
   }
 
+  // The module is "locked" when an object takes a reference on it. The first
+  // time it is locked, take a reference on crash reporting to bind its lifetime
+  // to the module.
+  virtual LONG Lock() throw() {
+    LONG result = ParentClass::Lock();
+    if (result == 1) {
+      DCHECK_EQ(crash_reporting_,
+                static_cast<chrome_frame::ScopedCrashReporting*>(NULL));
+      crash_reporting_ = new chrome_frame::ScopedCrashReporting();
+    }
+    return result;
+  }
+
+  // The module is "unlocked" when an object that had a reference on it is
+  // destroyed. The last time it is unlocked, release the reference on crash
+  // reporting.
+  virtual LONG Unlock() throw() {
+    LONG result = ParentClass::Unlock();
+    if (!result) {
+      DCHECK_NE(crash_reporting_,
+                static_cast<chrome_frame::ScopedCrashReporting*>(NULL));
+      delete crash_reporting_;
+      crash_reporting_ = NULL;
+    }
+    return result;
+  }
+
   // See comments in AddCommonRGSReplacements
   bool do_system_registration_;
+
+ private:
+  // A scoper created when the module is initially locked and destroyed when it
+  // is finally unlocked.
+  chrome_frame::ScopedCrashReporting* crash_reporting_;

[robertshield, 2013/03/13 17:22:27]

Could make this a scoped_ptr?

[grt (UTC plus 2), 2013/03/14 14:40:32]

No. I explicitly don't want it to be deleted when this instance is destroyed (at
exit or unload, probably under the loader lock). Comment added.

 };
 
 ChromeTabModule _AtlModule;
 
 base::AtExitManager* g_exit_manager = NULL;
 base::FieldTrialList* g_field_trial_list = NULL;
 
 HRESULT RefreshElevationPolicy() {
   const wchar_t kIEFrameDll[] = L"ieframe.dll";
   const char kIERefreshPolicy[] = "IERefreshElevationPolicy";
@@ skipping 337 matching lines @@
     result2 = key.WriteValue(L"ChromeTab.ChromeActiveDocument.1", 1);
   } else {
     result1 = key.DeleteValue(L"ChromeTab.ChromeActiveDocument");
     result2 = key.DeleteValue(L"ChromeTab.ChromeActiveDocument.1");
   }
 
   return result1 != ERROR_SUCCESS ? HRESULT_FROM_WIN32(result1) :
                                     HRESULT_FROM_WIN32(result2);
 }
 
+void OnPinModule() {
+  // Pin crash reporting by leaking a reference.
+  ignore_result(new chrome_frame::ScopedCrashReporting());
+}
+
 // Chrome Frame registration functions.
 //-----------------------------------------------------------------------------
 HRESULT RegisterSecuredMimeHandler(bool enable, bool is_system) {
   if (!is_system) {
     return SetOrDeleteMimeHandlerKey(enable, HKEY_CURRENT_USER);
   } else if (base::win::GetVersion() < base::win::VERSION_VISTA) {
     return SetOrDeleteMimeHandlerKey(enable, HKEY_LOCAL_MACHINE);
   }
 
   std::wstring mime_key = kInternetSettings;
@@ skipping 261 matching lines @@
   if (reason == DLL_PROCESS_ATTACH) {
 #ifndef NDEBUG
     // Silence traces from the ATL registrar to reduce the log noise.
     ATL::CTrace::s_trace.ChangeCategory(atlTraceRegistrar, 0,
                                         ATLTRACESTATUS_DISABLED);
 #endif
     InitGoogleUrl();
 
     g_exit_manager = new base::AtExitManager();
     CommandLine::Init(0, NULL);
-    InitializeCrashReporting();
     logging::InitLogging(
         NULL,
         logging::LOG_ONLY_TO_SYSTEM_DEBUG_LOG,
         logging::LOCK_LOG_FILE,
         logging::DELETE_OLD_LOG_FILE,
         logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS);
 
     // Log the same items as Chrome.
     logging::SetLogItems(true,  // enable_process_id
                          true,  // enable_thread_id
@@ skipping 12 matching lines @@
           << "Found CF module with no DllGetClassObject export.";
     }
 
     // Enable trace control and transport through event tracing for Windows.
     logging::LogEventProvider::Initialize(kChromeFrameProvider);
 
     // Initialize the field test infrastructure. Must be done somewhere that
     // can only get called once. For Chrome Frame, that is here.
     g_field_trial_list = new base::FieldTrialList(
         new metrics::SHA1EntropyProvider(MetricsService::GetClientID()));
+
+    // Set a callback so that crash reporting can be pinned when the module is
+    // pinned.
+    SetPinModuleCallback(&OnPinModule);
   } else if (reason == DLL_PROCESS_DETACH) {
     delete g_field_trial_list;
     g_field_trial_list = NULL;
 
     DllRedirector* dll_redirector = DllRedirector::GetInstance();
     DCHECK(dll_redirector);
     dll_redirector->UnregisterAsFirstCFModule();
 
     g_patch_helper.UnpatchIfNeeded();
 
     delete g_exit_manager;
     g_exit_manager = NULL;
-
-    ShutdownCrashReporting();
   }
   return _AtlModule.DllMain(reason, reserved);
 }
 
 // Used to determine whether the DLL can be unloaded by OLE
 STDAPI DllCanUnloadNow() {
   return _AtlModule.DllCanUnloadNow();
 }
 
 // Returns a class factory to create an object of the requested type
 STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv) {
+  chrome_frame::ScopedCrashReporting crash_reporting;
+
   // If we found another module present when we were loaded, then delegate to
   // that:
   if (g_dll_get_class_object_redir_ptr) {
     return g_dll_get_class_object_redir_ptr(rclsid, riid, ppv);
   }
 
   // Enable sniffing and switching only if asked for BHO
   // (we use BHO to get loaded in IE).
   if (rclsid == CLSID_ChromeFrameBHO) {
     g_patch_helper.InitializeAndPatchProtocolsIfNeeded();
   }
 
   return _AtlModule.DllGetClassObject(rclsid, riid, ppv);
 }
 
 // DllRegisterServer - Adds entries to the system registry
 STDAPI DllRegisterServer() {
+  chrome_frame::ScopedCrashReporting crash_reporting;
   uint16 flags =  ACTIVEX | ACTIVEDOC | TYPELIB | GCF_PROTOCOL |
                   BHO_CLSID | BHO_REGISTRATION;
 
   HRESULT hr = CustomRegistration(flags, true, true);
   if (SUCCEEDED(hr)) {
     SetupRunOnce();
   }
 
   return hr;
 }
 
 // DllUnregisterServer - Removes entries from the system registry
 STDAPI DllUnregisterServer() {
+  chrome_frame::ScopedCrashReporting crash_reporting;
   HRESULT hr = CustomRegistration(ALL, false, true);
   return hr;
 }
 
 // DllRegisterUserServer - Adds entries to the HKCU hive in the registry.
 STDAPI DllRegisterUserServer() {
+  chrome_frame::ScopedCrashReporting crash_reporting;
   UINT flags =  ACTIVEX | ACTIVEDOC | TYPELIB | GCF_PROTOCOL |
                 BHO_CLSID | BHO_REGISTRATION;
 
   HRESULT hr = CustomRegistration(flags, TRUE, false);
   if (SUCCEEDED(hr)) {
     SetupRunOnce();
   }
 
   return hr;
 }
 
 // DllUnregisterUserServer - Removes entries from the HKCU hive in the registry.
 STDAPI DllUnregisterUserServer() {
+  chrome_frame::ScopedCrashReporting crash_reporting;
   HRESULT hr = CustomRegistration(ALL, FALSE, false);
   return hr;
 }
 
 // Object entries go here instead of with each object, so that we can move
 // the objects to a lib. Also reduces magic.
 OBJECT_ENTRY_AUTO(CLSID_ChromeFrameBHO, Bho)
 OBJECT_ENTRY_AUTO(__uuidof(ChromeActiveDocument), ChromeActiveDocument)
 OBJECT_ENTRY_AUTO(__uuidof(ChromeFrame), ChromeFrameActivex)
 OBJECT_ENTRY_AUTO(__uuidof(ChromeProtocol), ChromeProtocol)