Lazy initialization for ProcessesEventRouter.

chrome/browser/extensions/extension_system.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 "chrome/browser/extensions/extension_system.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/string_tokenizer.h"
@@ skipping 53 matching lines @@
 ExtensionSystem* ExtensionSystem::Get(Profile* profile) {
   return ExtensionSystemFactory::GetForProfile(profile);
 }
 
 //
 // ExtensionSystemImpl::Shared
 //
 
 ExtensionSystemImpl::Shared::Shared(Profile* profile)
     : profile_(profile) {
+  event_router_.reset(new EventRouter(profile_));

[Aaron Boodman, 2012/11/07 23:51:28]

Why not make it part of the initializer list?

[Yoyo Zhou, 2012/11/08 00:18:16]

See below.

 }
 
 ExtensionSystemImpl::Shared::~Shared() {
 }
 
 void ExtensionSystemImpl::Shared::InitPrefs() {
   bool extensions_disabled =
       profile_->GetPrefs()->GetBoolean(prefs::kDisableExtensions) ||
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableExtensions);
   extension_prefs_.reset(new ExtensionPrefs(
       profile_->GetPrefs(),
       profile_->GetPath().AppendASCII(ExtensionService::kInstallDirectoryName),
       ExtensionPrefValueMapFactory::GetForProfile(profile_)));
   extension_prefs_->Init(extensions_disabled);
+  // Tell the EventRouter that ExtensionPrefs are ready.
+  event_router_->InitWithPrefs(extension_prefs_.get());

[Aaron Boodman, 2012/11/07 23:51:28]

Shared::InitPrefs() is called in the constructor. Isn't it possible to pass the
prefs into the ctor and get rid of this method?

[Yoyo Zhou, 2012/11/08 00:18:16]

Yes, I was misinterpreting what was going on. I'll go back to how it was before
(except initializing it here).

 
   state_store_.reset(new StateStore(
       profile_,
       profile_->GetPath().AppendASCII(ExtensionService::kStateStoreName)));
 
   shell_window_geometry_cache_.reset(new ShellWindowGeometryCache(
     profile_, state_store_.get()));
 }
 
 void ExtensionSystemImpl::Shared::RegisterManagementPolicyProviders() {
   DCHECK(extension_prefs_.get());
   management_policy_->RegisterProvider(extension_prefs_.get());
 }
 
 void ExtensionSystemImpl::Shared::Init(bool extensions_enabled) {
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
 
   lazy_background_task_queue_.reset(new LazyBackgroundTaskQueue(profile_));
   message_service_.reset(new MessageService(lazy_background_task_queue_.get()));
-  extension_event_router_.reset(new EventRouter(profile_,
-                                                extension_prefs_.get()));
   navigation_observer_.reset(new NavigationObserver(profile_));
 
   ExtensionErrorReporter::Init(true);  // allow noisy errors.
 
   user_script_master_ = new UserScriptMaster(profile_);
 
   bool autoupdate_enabled = true;
 #if defined(OS_CHROMEOS)
   if (!extensions_enabled)
     autoupdate_enabled = false;
@@ skipping 111 matching lines @@
 LazyBackgroundTaskQueue*
     ExtensionSystemImpl::Shared::lazy_background_task_queue() {
   return lazy_background_task_queue_.get();
 }
 
 MessageService* ExtensionSystemImpl::Shared::message_service() {
   return message_service_.get();
 }
 
 EventRouter* ExtensionSystemImpl::Shared::event_router() {
-  return extension_event_router_.get();
+  return event_router_.get();
 }
 
 //
 // ExtensionSystemImpl
 //
 
 ExtensionSystemImpl::ExtensionSystemImpl(Profile* profile)
     : profile_(profile),
       extension_devtools_manager_(NULL) {
   shared_ = ExtensionSystemSharedFactory::GetForProfile(profile);
@@ skipping 142 matching lines @@
 void ExtensionSystemImpl::UnregisterExtensionWithRequestContexts(
     const std::string& extension_id,
     const extension_misc::UnloadedExtensionReason reason) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ExtensionInfoMap::RemoveExtension, info_map(),
                  extension_id, reason));
 }
 
 }  // namespace extensions