Ok, here is a different approach at this change.

chrome/browser/extensions/extensions_service.cc

 // Copyright (c) 2009 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 "chrome/browser/extensions/extensions_service.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/histogram.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_bookmarks_module.h"
 #include "chrome/browser/extensions/extension_browser_event_router.h"
 #include "chrome/browser/extensions/extension_dom_ui.h"
 #include "chrome/browser/extensions/extension_file_util.h"
 #include "chrome/browser/extensions/extension_history_api.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_updater.h"
 #include "chrome/browser/extensions/external_extension_provider.h"
 #include "chrome/browser/extensions/external_pref_extension_provider.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
+#include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_reporter.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/common/url_constants.h"
 
@@ skipping 211 matching lines @@
   extensions_.push_back(extension);
   ExtensionList::iterator iter = std::find(disabled_extensions_.begin(),
                                            disabled_extensions_.end(),
                                            extension);
   disabled_extensions_.erase(iter);
 
   ExtensionDOMUI::RegisterChromeURLOverrides(profile_,
       extension->GetChromeURLOverrides());
 
   NotifyExtensionLoaded(extension);
+  UpdateActiveExtensionsInCrashReporter();
 }
 
 void ExtensionsService::DisableExtension(const std::string& extension_id) {
   Extension* extension = GetExtensionByIdInternal(extension_id, true, false);
   if (!extension) {
     NOTREACHED() << "Trying to disable an extension that isn't enabled.";
     return;
   }
 
   // Remember that we disabled it, unless it's temporary.
   if (extension->location() != Extension::LOAD)
     extension_prefs_->SetExtensionState(extension, Extension::DISABLED);
 
   // Move it over to the disabled list.
   disabled_extensions_.push_back(extension);
   ExtensionList::iterator iter = std::find(extensions_.begin(),
                                            extensions_.end(),
                                            extension);
   extensions_.erase(iter);
 
   ExtensionDOMUI::UnregisterChromeURLOverrides(profile_,
       extension->GetChromeURLOverrides());
 
   NotifyExtensionUnloaded(extension);
+  UpdateActiveExtensionsInCrashReporter();
 }
 
 void ExtensionsService::LoadExtension(const FilePath& extension_path) {
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(
           backend_.get(),
           &ExtensionsServiceBackend::LoadSingleExtension,
           extension_path, scoped_refptr<ExtensionsService>(this)));
 }
@@ skipping 198 matching lines @@
         Details<Extension>(extension.get()));
     return;
   }
 
   iter = std::find(extensions_.begin(), extensions_.end(), extension.get());
 
   // Remove the extension from our list.
   extensions_.erase(iter);
 
   NotifyExtensionUnloaded(extension.get());
+  UpdateActiveExtensionsInCrashReporter();
 }
 
 void ExtensionsService::UnloadAllExtensions() {
   ExtensionList::iterator iter;
   for (iter = extensions_.begin(); iter != extensions_.end(); ++iter)
     delete *iter;
   extensions_.clear();
 
   // TODO(erikkay) should there be a notification for this?  We can't use
   // EXTENSION_UNLOADED since that implies that the extension has been disabled
@@ skipping 103 matching lines @@
             NotificationType::EXTENSION_UPDATE_DISABLED,
             Source<Profile>(profile_),
             Details<Extension>(extension));
         disabled_extensions_.push_back(scoped_extension.release());
         break;
       default:
         NOTREACHED();
         break;
     }
   }
+
+  UpdateActiveExtensionsInCrashReporter();
+}
+
+void ExtensionsService::UpdateActiveExtensionsInCrashReporter() {
+  std::vector<std::string> extension_ids;
+  for (size_t i = 0; i < extensions_.size(); ++i) {
+    if (!extensions_[i]->IsTheme())
+      extension_ids.push_back(extensions_[i]->id());
+  }
+
+  child_process_logging::SetActiveExtensions(extension_ids);
 }
 
 void ExtensionsService::OnExtensionInstalled(Extension* extension,
                                              bool allow_privilege_increase) {
   extension_prefs_->OnExtensionInstalled(extension);
 
   // If the extension is a theme, tell the profile (and therefore ThemeProvider)
   // to apply it.
   if (extension->IsTheme()) {
     NotificationService::current()->Notify(
@@ skipping 330 matching lines @@
 
 void ExtensionsServiceBackend::OnExternalExtensionFound(
     const std::string& id, const Version* version, const FilePath& path,
     Extension::Location location) {
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(
           frontend_, &ExtensionsService::OnExternalExtensionFound, id,
           version->GetString(), path, location));
 }