src/extensions/browser/process_manager.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "extensions/browser/process_manager.h"
   6
   7 #include "base/bind.h"
   8 #include "base/command_line.h"
   9 #include "base/lazy_instance.h"
  10 #include "base/logging.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/metrics/histogram.h"
  13 #include "base/stl_util.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "base/time/time.h"
  16 #include "content/public/browser/browser_context.h"
  17 #include "content/public/browser/browser_thread.h"
  18 #include "content/public/browser/devtools_agent_host.h"
  19 #include "content/public/browser/notification_service.h"
  20 #include "content/public/browser/render_frame_host.h"
  21 #include "content/public/browser/render_process_host.h"
  22 #include "content/public/browser/render_view_host.h"
  23 #include "content/public/browser/site_instance.h"
  24 #include "content/public/browser/web_contents.h"
  25 #include "content/public/browser/web_contents_delegate.h"
  26 #include "content/public/browser/web_contents_observer.h"
  27 #include "content/public/browser/web_contents_user_data.h"
  28 #include "content/public/common/renderer_preferences.h"
  29 #include "content/public/common/url_constants.h"
  30 #include "extensions/browser/extension_host.h"
  31 #include "extensions/browser/extension_registry.h"
  32 #include "extensions/browser/extension_system.h"
  33 #include "extensions/browser/extensions_browser_client.h"
  34 #include "extensions/browser/notification_types.h"
  35 #include "extensions/browser/process_manager_delegate.h"
  36 #include "extensions/browser/process_manager_observer.h"
  37 #include "extensions/browser/view_type_utils.h"
  38 #include "extensions/common/constants.h"
  39 #include "extensions/common/extension.h"
  40 #include "extensions/common/extension_messages.h"
  41 #include "extensions/common/manifest_handlers/background_info.h"
  42 #include "extensions/common/manifest_handlers/incognito_info.h"
  43 #include "extensions/common/one_shot_event.h"
  44
  45 using content::BrowserContext;
  46 using content::RenderViewHost;
  47 using content::SiteInstance;
  48 using content::WebContents;
  49
  50 namespace extensions {
  51 class RenderViewHostDestructionObserver;
  52 }
  53 DEFINE_WEB_CONTENTS_USER_DATA_KEY(
  54     extensions::RenderViewHostDestructionObserver);
  55
  56 namespace extensions {
  57
  58 namespace {
  59
  60 // The time to delay between an extension becoming idle and
  61 // sending a ShouldSuspend message.
  62 // Note: Must be sufficiently larger (e.g. 2x) than
  63 // kKeepaliveThrottleIntervalInSeconds in ppapi/proxy/plugin_globals.
  64 unsigned g_event_page_idle_time_msec = 10000;
  65
  66 // The time to delay between sending a ShouldSuspend message and
  67 // sending a Suspend message.
  68 unsigned g_event_page_suspending_time_msec = 5000;
  69
  70 std::string GetExtensionID(RenderViewHost* render_view_host) {
  71   // This works for both apps and extensions because the site has been
  72   // normalized to the extension URL for hosted apps.
  73   content::SiteInstance* site_instance = render_view_host->GetSiteInstance();
  74   if (!site_instance)
  75     return std::string();
  76
  77   const GURL& site_url = site_instance->GetSiteURL();
  78
  79   if (!site_url.SchemeIs(kExtensionScheme) &&
  80       !site_url.SchemeIs(content::kGuestScheme))
  81     return std::string();
  82
  83   return site_url.host();
  84 }
  85
  86 std::string GetExtensionIDFromFrame(
  87     content::RenderFrameHost* render_frame_host) {
  88   // This works for both apps and extensions because the site has been
  89   // normalized to the extension URL for apps.
  90   if (!render_frame_host->GetSiteInstance())
  91     return std::string();
  92
  93   return render_frame_host->GetSiteInstance()->GetSiteURL().host();
  94 }
  95
  96 bool IsFrameInExtensionHost(ExtensionHost* extension_host,
  97                             content::RenderFrameHost* render_frame_host) {
  98   return WebContents::FromRenderFrameHost(render_frame_host) ==
  99       extension_host->host_contents();
 100 }
 101
 102 void OnRenderViewHostUnregistered(BrowserContext* context,
 103                                   RenderViewHost* render_view_host) {
 104   content::NotificationService::current()->Notify(
 105       extensions::NOTIFICATION_EXTENSION_VIEW_UNREGISTERED,
 106       content::Source<BrowserContext>(context),
 107       content::Details<RenderViewHost>(render_view_host));
 108 }
 109
 110 // Incognito profiles use this process manager. It is mostly a shim that decides
 111 // whether to fall back on the original profile's ProcessManager based
 112 // on whether a given extension uses "split" or "spanning" incognito behavior.
 113 class IncognitoProcessManager : public ProcessManager {
 114  public:
 115   IncognitoProcessManager(BrowserContext* incognito_context,
 116                           BrowserContext* original_context,
 117                           ProcessManager* original_manager,
 118                           ExtensionRegistry* extension_registry);
 119   virtual ~IncognitoProcessManager() {}
 120   virtual bool CreateBackgroundHost(const Extension* extension,
 121                                     const GURL& url) OVERRIDE;
 122   virtual SiteInstance* GetSiteInstanceForURL(const GURL& url) OVERRIDE;
 123
 124  private:
 125   ProcessManager* original_manager_;
 126
 127   DISALLOW_COPY_AND_ASSIGN(IncognitoProcessManager);
 128 };
 129
 130 static void CreateBackgroundHostForExtensionLoad(
 131     ProcessManager* manager, const Extension* extension) {
 132   DVLOG(1) << "CreateBackgroundHostForExtensionLoad";
 133   if (BackgroundInfo::HasPersistentBackgroundPage(extension))
 134     manager->CreateBackgroundHost(extension,
 135                                   BackgroundInfo::GetBackgroundURL(extension));
 136 }
 137
 138 }  // namespace
 139
 140 class RenderViewHostDestructionObserver
 141     : public content::WebContentsObserver,
 142       public content::WebContentsUserData<RenderViewHostDestructionObserver> {
 143  public:
 144   virtual ~RenderViewHostDestructionObserver() {}
 145
 146  private:
 147   explicit RenderViewHostDestructionObserver(WebContents* web_contents)
 148       : WebContentsObserver(web_contents) {
 149     BrowserContext* context = web_contents->GetBrowserContext();
 150     process_manager_ = ExtensionSystem::Get(context)->process_manager();
 151   }
 152
 153   friend class content::WebContentsUserData<RenderViewHostDestructionObserver>;
 154
 155   // content::WebContentsObserver overrides.
 156   virtual void RenderViewDeleted(RenderViewHost* render_view_host) OVERRIDE {
 157     process_manager_->UnregisterRenderViewHost(render_view_host);
 158   }
 159
 160   ProcessManager* process_manager_;
 161
 162   DISALLOW_COPY_AND_ASSIGN(RenderViewHostDestructionObserver);
 163 };
 164
 165 struct ProcessManager::BackgroundPageData {
 166   // The count of things keeping the lazy background page alive.
 167   int lazy_keepalive_count;
 168
 169   // Tracks if an impulse event has occured since the last polling check.
 170   bool keepalive_impulse;
 171   bool previous_keepalive_impulse;
 172
 173   // True if the page responded to the ShouldSuspend message and is currently
 174   // dispatching the suspend event. During this time any events that arrive will
 175   // cancel the suspend process and an onSuspendCanceled event will be
 176   // dispatched to the page.
 177   bool is_closing;
 178
 179   // Stores the value of the incremented
 180   // ProcessManager::last_background_close_sequence_id_ whenever the extension
 181   // is active. A copy of the ID is also passed in the callbacks and IPC
 182   // messages leading up to CloseLazyBackgroundPageNow. The process is aborted
 183   // if the IDs ever differ due to new activity.
 184   uint64 close_sequence_id;
 185
 186   // Keeps track of when this page was last suspended. Used for perf metrics.
 187   linked_ptr<base::ElapsedTimer> since_suspended;
 188
 189   BackgroundPageData()
 190       : lazy_keepalive_count(0),
 191         keepalive_impulse(false),
 192         previous_keepalive_impulse(false),
 193         is_closing(false),
 194         close_sequence_id(0) {}
 195 };
 196
 197 //
 198 // ProcessManager
 199 //
 200
 201 // static
 202 ProcessManager* ProcessManager::Create(BrowserContext* context) {
 203   ExtensionRegistry* extension_registry = ExtensionRegistry::Get(context);
 204   ExtensionsBrowserClient* client = ExtensionsBrowserClient::Get();
 205   if (client->IsGuestSession(context)) {
 206     // In the guest session, there is a single off-the-record context.  Unlike
 207     // a regular incognito mode, background pages of extensions must be
 208     // created regardless of whether extensions use "spanning" or "split"
 209     // incognito behavior.
 210     BrowserContext* original_context = client->GetOriginalContext(context);
 211     return new ProcessManager(context, original_context, extension_registry);
 212   }
 213
 214   if (context->IsOffTheRecord()) {
 215     BrowserContext* original_context = client->GetOriginalContext(context);
 216     ProcessManager* original_manager =
 217         ExtensionSystem::Get(original_context)->process_manager();
 218     return new IncognitoProcessManager(
 219         context, original_context, original_manager, extension_registry);
 220   }
 221
 222   return new ProcessManager(context, context, extension_registry);
 223 }
 224
 225 // static
 226 ProcessManager* ProcessManager::CreateForTesting(
 227     BrowserContext* context,
 228     ExtensionRegistry* extension_registry) {
 229   DCHECK(!context->IsOffTheRecord());
 230   return new ProcessManager(context, context, extension_registry);
 231 }
 232
 233 // static
 234 ProcessManager* ProcessManager::CreateIncognitoForTesting(
 235     BrowserContext* incognito_context,
 236     BrowserContext* original_context,
 237     ProcessManager* original_manager,
 238     ExtensionRegistry* extension_registry) {
 239   DCHECK(incognito_context->IsOffTheRecord());
 240   DCHECK(!original_context->IsOffTheRecord());
 241   return new IncognitoProcessManager(incognito_context,
 242                                      original_context,
 243                                      original_manager,
 244                                      extension_registry);
 245 }
 246
 247 ProcessManager::ProcessManager(BrowserContext* context,
 248                                BrowserContext* original_context,
 249                                ExtensionRegistry* extension_registry)
 250     : site_instance_(SiteInstance::Create(context)),
 251       extension_registry_(extension_registry),
 252       startup_background_hosts_created_(false),
 253       devtools_callback_(base::Bind(&ProcessManager::OnDevToolsStateChanged,
 254                                     base::Unretained(this))),
 255       last_background_close_sequence_id_(0),
 256       weak_ptr_factory_(this) {
 257   // ExtensionRegistry is shared between incognito and regular contexts.
 258   DCHECK_EQ(original_context, extension_registry_->browser_context());
 259   registrar_.Add(this,
 260                  extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
 261                  content::Source<BrowserContext>(original_context));
 262   registrar_.Add(this,
 263                  extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
 264                  content::Source<BrowserContext>(original_context));
 265   registrar_.Add(this,
 266                  extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
 267                  content::Source<BrowserContext>(original_context));
 268   registrar_.Add(this,
 269                  extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
 270                  content::Source<BrowserContext>(context));
 271   registrar_.Add(this,
 272                  extensions::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE,
 273                  content::Source<BrowserContext>(context));
 274   registrar_.Add(this, content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
 275                  content::NotificationService::AllSources());
 276   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_CONNECTED,
 277                  content::NotificationService::AllSources());
 278
 279   content::DevToolsAgentHost::AddAgentStateCallback(devtools_callback_);
 280
 281   OnKeepaliveImpulseCheck();
 282 }
 283
 284 ProcessManager::~ProcessManager() {
 285   CloseBackgroundHosts();
 286   DCHECK(background_hosts_.empty());
 287   content::DevToolsAgentHost::RemoveAgentStateCallback(devtools_callback_);
 288 }
 289
 290 const ProcessManager::ViewSet ProcessManager::GetAllViews() const {
 291   ViewSet result;
 292   for (ExtensionRenderViews::const_iterator iter =
 293            all_extension_views_.begin();
 294        iter != all_extension_views_.end(); ++iter) {
 295     result.insert(iter->first);
 296   }
 297   return result;
 298 }
 299
 300 void ProcessManager::AddObserver(ProcessManagerObserver* observer) {
 301   observer_list_.AddObserver(observer);
 302 }
 303
 304 void ProcessManager::RemoveObserver(ProcessManagerObserver* observer) {
 305   observer_list_.RemoveObserver(observer);
 306 }
 307
 308 bool ProcessManager::CreateBackgroundHost(const Extension* extension,
 309                                           const GURL& url) {
 310   // Hosted apps are taken care of from BackgroundContentsService. Ignore them
 311   // here.
 312   if (extension->is_hosted_app())
 313     return false;
 314
 315   // Don't create hosts if the embedder doesn't allow it.
 316   ProcessManagerDelegate* delegate =
 317       ExtensionsBrowserClient::Get()->GetProcessManagerDelegate();
 318   if (delegate && !delegate->IsBackgroundPageAllowed(GetBrowserContext()))
 319     return false;
 320
 321   // Don't create multiple background hosts for an extension.
 322   if (GetBackgroundHostForExtension(extension->id()))
 323     return true;  // TODO(kalman): return false here? It might break things...
 324
 325   ExtensionHost* host =
 326       new ExtensionHost(extension, GetSiteInstanceForURL(url), url,
 327                         VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
 328   host->CreateRenderViewSoon();
 329   OnBackgroundHostCreated(host);
 330   return true;
 331 }
 332
 333 ExtensionHost* ProcessManager::GetBackgroundHostForExtension(
 334     const std::string& extension_id) {
 335   for (ExtensionHostSet::iterator iter = background_hosts_.begin();
 336        iter != background_hosts_.end(); ++iter) {
 337     ExtensionHost* host = *iter;
 338     if (host->extension_id() == extension_id)
 339       return host;
 340   }
 341   return NULL;
 342 }
 343
 344 std::set<RenderViewHost*> ProcessManager::GetRenderViewHostsForExtension(
 345     const std::string& extension_id) {
 346   std::set<RenderViewHost*> result;
 347
 348   SiteInstance* site_instance = GetSiteInstanceForURL(
 349       Extension::GetBaseURLFromExtensionId(extension_id));
 350   if (!site_instance)
 351     return result;
 352
 353   // Gather up all the views for that site.
 354   for (ExtensionRenderViews::iterator view = all_extension_views_.begin();
 355        view != all_extension_views_.end(); ++view) {
 356     if (view->first->GetSiteInstance() == site_instance)
 357       result.insert(view->first);
 358   }
 359
 360   return result;
 361 }
 362
 363 const Extension* ProcessManager::GetExtensionForRenderViewHost(
 364     RenderViewHost* render_view_host) {
 365   if (!render_view_host->GetSiteInstance())
 366     return NULL;
 367
 368   return extension_registry_->enabled_extensions().GetByID(
 369       GetExtensionID(render_view_host));
 370 }
 371
 372 void ProcessManager::UnregisterRenderViewHost(
 373     RenderViewHost* render_view_host) {
 374   ExtensionRenderViews::iterator view =
 375       all_extension_views_.find(render_view_host);
 376   if (view == all_extension_views_.end())
 377     return;
 378
 379   OnRenderViewHostUnregistered(GetBrowserContext(), render_view_host);
 380   ViewType view_type = view->second;
 381   all_extension_views_.erase(view);
 382
 383   // Keepalive count, balanced in RegisterRenderViewHost.
 384   if (view_type != VIEW_TYPE_INVALID &&
 385       view_type != VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
 386     const Extension* extension = GetExtensionForRenderViewHost(
 387         render_view_host);
 388     if (extension)
 389       DecrementLazyKeepaliveCount(extension);
 390   }
 391 }
 392
 393 bool ProcessManager::RegisterRenderViewHost(RenderViewHost* render_view_host) {
 394   const Extension* extension = GetExtensionForRenderViewHost(
 395       render_view_host);
 396   if (!extension)
 397     return false;
 398
 399   WebContents* web_contents = WebContents::FromRenderViewHost(render_view_host);
 400   all_extension_views_[render_view_host] = GetViewType(web_contents);
 401
 402   // Keep the lazy background page alive as long as any non-background-page
 403   // extension views are visible. Keepalive count balanced in
 404   // UnregisterRenderViewHost.
 405   IncrementLazyKeepaliveCountForView(render_view_host);
 406   return true;
 407 }
 408
 409 SiteInstance* ProcessManager::GetSiteInstanceForURL(const GURL& url) {
 410   return site_instance_->GetRelatedSiteInstance(url);
 411 }
 412
 413 bool ProcessManager::IsBackgroundHostClosing(const std::string& extension_id) {
 414   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
 415   return (host && background_page_data_[extension_id].is_closing);
 416 }
 417
 418 int ProcessManager::GetLazyKeepaliveCount(const Extension* extension) {
 419   if (!BackgroundInfo::HasLazyBackgroundPage(extension))
 420     return 0;
 421
 422   return background_page_data_[extension->id()].lazy_keepalive_count;
 423 }
 424
 425 void ProcessManager::IncrementLazyKeepaliveCount(const Extension* extension) {
 426   if (!BackgroundInfo::HasLazyBackgroundPage(extension))
 427     return;
 428
 429   int& count = background_page_data_[extension->id()].lazy_keepalive_count;
 430   if (++count == 1)
 431     OnLazyBackgroundPageActive(extension->id());
 432 }
 433
 434 void ProcessManager::DecrementLazyKeepaliveCount(const Extension* extension) {
 435   if (!BackgroundInfo::HasLazyBackgroundPage(extension))
 436     return;
 437   DecrementLazyKeepaliveCount(extension->id());
 438 }
 439
 440 void ProcessManager::DecrementLazyKeepaliveCount(
 441     const std::string& extension_id) {
 442   int& count = background_page_data_[extension_id].lazy_keepalive_count;
 443   DCHECK(count > 0 ||
 444          !extension_registry_->enabled_extensions().Contains(extension_id));
 445
 446   // If we reach a zero keepalive count when the lazy background page is about
 447   // to be closed, incrementing close_sequence_id will cancel the close
 448   // sequence and cause the background page to linger. So check is_closing
 449   // before initiating another close sequence.
 450   if (--count == 0 && !background_page_data_[extension_id].is_closing) {
 451     background_page_data_[extension_id].close_sequence_id =
 452         ++last_background_close_sequence_id_;
 453     base::MessageLoop::current()->PostDelayedTask(
 454         FROM_HERE,
 455         base::Bind(&ProcessManager::OnLazyBackgroundPageIdle,
 456                    weak_ptr_factory_.GetWeakPtr(),
 457                    extension_id,
 458                    last_background_close_sequence_id_),
 459         base::TimeDelta::FromMilliseconds(g_event_page_idle_time_msec));
 460   }
 461 }
 462
 463 void ProcessManager::IncrementLazyKeepaliveCountForView(
 464     RenderViewHost* render_view_host) {
 465   WebContents* web_contents =
 466       WebContents::FromRenderViewHost(render_view_host);
 467   ViewType view_type = GetViewType(web_contents);
 468   if (view_type != VIEW_TYPE_INVALID &&
 469       view_type != VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
 470     const Extension* extension = GetExtensionForRenderViewHost(
 471         render_view_host);
 472     if (extension)
 473       IncrementLazyKeepaliveCount(extension);
 474   }
 475 }
 476
 477 // This implementation layers on top of the keepalive count. An impulse sets
 478 // a per extension flag. On a regular interval that flag is checked. Changes
 479 // from the flag not being set to set cause an IncrementLazyKeepaliveCount.
 480 void ProcessManager::KeepaliveImpulse(const Extension* extension) {
 481   if (!BackgroundInfo::HasLazyBackgroundPage(extension))
 482     return;
 483
 484   BackgroundPageData& bd = background_page_data_[extension->id()];
 485
 486   if (!bd.keepalive_impulse) {
 487     bd.keepalive_impulse = true;
 488     if (!bd.previous_keepalive_impulse) {
 489       IncrementLazyKeepaliveCount(extension);
 490     }
 491   }
 492
 493   if (!keepalive_impulse_callback_for_testing_.is_null()) {
 494     ImpulseCallbackForTesting callback_may_clear_callbacks_reentrantly =
 495       keepalive_impulse_callback_for_testing_;
 496     callback_may_clear_callbacks_reentrantly.Run(extension->id());
 497   }
 498 }
 499
 500 // static
 501 void ProcessManager::OnKeepaliveFromPlugin(int render_process_id,
 502                                            int render_frame_id,
 503                                            const std::string& extension_id) {
 504   content::RenderFrameHost* render_frame_host =
 505       content::RenderFrameHost::FromID(render_process_id, render_frame_id);
 506   if (!render_frame_host)
 507     return;
 508
 509   content::SiteInstance* site_instance = render_frame_host->GetSiteInstance();
 510   if (!site_instance)
 511     return;
 512
 513   BrowserContext* browser_context = site_instance->GetBrowserContext();
 514   const Extension* extension =
 515       ExtensionRegistry::Get(browser_context)->enabled_extensions().GetByID(
 516           extension_id);
 517   if (!extension)
 518     return;
 519
 520   ProcessManager* pm = ExtensionSystem::Get(browser_context)->process_manager();
 521   if (!pm)
 522     return;
 523
 524   pm->KeepaliveImpulse(extension);
 525 }
 526
 527 // DecrementLazyKeepaliveCount is called when no calls to KeepaliveImpulse
 528 // have been made for at least g_event_page_idle_time_msec. In the best case an
 529 // impulse was made just before being cleared, and the decrement will occur
 530 // g_event_page_idle_time_msec later, causing a 2 * g_event_page_idle_time_msec
 531 // total time for extension to be shut down based on impulses. Worst case is
 532 // an impulse just after a clear, adding one check cycle and resulting in 3x
 533 // total time.
 534 void ProcessManager::OnKeepaliveImpulseCheck() {
 535   for (BackgroundPageDataMap::iterator i = background_page_data_.begin();
 536        i != background_page_data_.end();
 537        ++i) {
 538     if (i->second.previous_keepalive_impulse && !i->second.keepalive_impulse) {
 539       DecrementLazyKeepaliveCount(i->first);
 540       if (!keepalive_impulse_decrement_callback_for_testing_.is_null()) {
 541         ImpulseCallbackForTesting callback_may_clear_callbacks_reentrantly =
 542           keepalive_impulse_decrement_callback_for_testing_;
 543         callback_may_clear_callbacks_reentrantly.Run(i->first);
 544       }
 545     }
 546
 547     i->second.previous_keepalive_impulse = i->second.keepalive_impulse;
 548     i->second.keepalive_impulse = false;
 549   }
 550
 551   // OnKeepaliveImpulseCheck() is always called in constructor, but in unit
 552   // tests there will be no message loop. In that event don't schedule tasks.
 553   if (base::MessageLoop::current()) {
 554     base::MessageLoop::current()->PostDelayedTask(
 555         FROM_HERE,
 556         base::Bind(&ProcessManager::OnKeepaliveImpulseCheck,
 557                    weak_ptr_factory_.GetWeakPtr()),
 558         base::TimeDelta::FromMilliseconds(g_event_page_idle_time_msec));
 559   }
 560 }
 561
 562 void ProcessManager::OnLazyBackgroundPageIdle(const std::string& extension_id,
 563                                               uint64 sequence_id) {
 564   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
 565   if (host && !background_page_data_[extension_id].is_closing &&
 566       sequence_id == background_page_data_[extension_id].close_sequence_id) {
 567     // Tell the renderer we are about to close. This is a simple ping that the
 568     // renderer will respond to. The purpose is to control sequencing: if the
 569     // extension remains idle until the renderer responds with an ACK, then we
 570     // know that the extension process is ready to shut down. If our
 571     // close_sequence_id has already changed, then we would ignore the
 572     // ShouldSuspendAck, so we don't send the ping.
 573     host->render_view_host()->Send(new ExtensionMsg_ShouldSuspend(
 574         extension_id, sequence_id));
 575   }
 576 }
 577
 578 void ProcessManager::OnLazyBackgroundPageActive(
 579     const std::string& extension_id) {
 580   if (!background_page_data_[extension_id].is_closing) {
 581     // Cancel the current close sequence by changing the close_sequence_id,
 582     // which causes us to ignore the next ShouldSuspendAck.
 583     background_page_data_[extension_id].close_sequence_id =
 584         ++last_background_close_sequence_id_;
 585   }
 586 }
 587
 588 void ProcessManager::OnShouldSuspendAck(const std::string& extension_id,
 589                                         uint64 sequence_id) {
 590   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
 591   if (host &&
 592       sequence_id == background_page_data_[extension_id].close_sequence_id) {
 593     host->render_view_host()->Send(new ExtensionMsg_Suspend(extension_id));
 594   }
 595 }
 596
 597 void ProcessManager::OnSuspendAck(const std::string& extension_id) {
 598   background_page_data_[extension_id].is_closing = true;
 599   uint64 sequence_id = background_page_data_[extension_id].close_sequence_id;
 600   base::MessageLoop::current()->PostDelayedTask(
 601       FROM_HERE,
 602       base::Bind(&ProcessManager::CloseLazyBackgroundPageNow,
 603                  weak_ptr_factory_.GetWeakPtr(),
 604                  extension_id,
 605                  sequence_id),
 606       base::TimeDelta::FromMilliseconds(g_event_page_suspending_time_msec));
 607 }
 608
 609 void ProcessManager::CloseLazyBackgroundPageNow(const std::string& extension_id,
 610                                                 uint64 sequence_id) {
 611   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
 612   if (host &&
 613       sequence_id == background_page_data_[extension_id].close_sequence_id) {
 614     ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
 615     if (host)
 616       CloseBackgroundHost(host);
 617   }
 618 }
 619
 620 void ProcessManager::OnNetworkRequestStarted(
 621     content::RenderFrameHost* render_frame_host) {
 622   ExtensionHost* host = GetBackgroundHostForExtension(
 623       GetExtensionIDFromFrame(render_frame_host));
 624   if (host && IsFrameInExtensionHost(host, render_frame_host))
 625     IncrementLazyKeepaliveCount(host->extension());
 626 }
 627
 628 void ProcessManager::OnNetworkRequestDone(
 629     content::RenderFrameHost* render_frame_host) {
 630   ExtensionHost* host = GetBackgroundHostForExtension(
 631       GetExtensionIDFromFrame(render_frame_host));
 632   if (host && IsFrameInExtensionHost(host, render_frame_host))
 633     DecrementLazyKeepaliveCount(host->extension());
 634 }
 635
 636 void ProcessManager::CancelSuspend(const Extension* extension) {
 637   bool& is_closing = background_page_data_[extension->id()].is_closing;
 638   ExtensionHost* host = GetBackgroundHostForExtension(extension->id());
 639   if (host && is_closing) {
 640     is_closing = false;
 641     host->render_view_host()->Send(
 642         new ExtensionMsg_CancelSuspend(extension->id()));
 643     // This increment / decrement is to simulate an instantaneous event. This
 644     // has the effect of invalidating close_sequence_id, preventing any in
 645     // progress closes from completing and starting a new close process if
 646     // necessary.
 647     IncrementLazyKeepaliveCount(extension);
 648     DecrementLazyKeepaliveCount(extension);
 649   }
 650 }
 651
 652 void ProcessManager::CloseBackgroundHosts() {
 653   for (ExtensionHostSet::iterator iter = background_hosts_.begin();
 654        iter != background_hosts_.end();) {
 655     ExtensionHostSet::iterator current = iter++;
 656     delete *current;
 657   }
 658 }
 659
 660 content::BrowserContext* ProcessManager::GetBrowserContext() const {
 661   return site_instance_->GetBrowserContext();
 662 }
 663
 664 void ProcessManager::SetKeepaliveImpulseCallbackForTesting(
 665     const ImpulseCallbackForTesting& callback) {
 666   keepalive_impulse_callback_for_testing_ = callback;
 667 }
 668
 669 void ProcessManager::SetKeepaliveImpulseDecrementCallbackForTesting(
 670     const ImpulseCallbackForTesting& callback) {
 671   keepalive_impulse_decrement_callback_for_testing_ = callback;
 672 }
 673
 674 // static
 675 void ProcessManager::SetEventPageIdleTimeForTesting(unsigned idle_time_msec) {
 676   CHECK_GT(idle_time_msec, 0u);  // OnKeepaliveImpulseCheck requires non zero.
 677   g_event_page_idle_time_msec = idle_time_msec;
 678 }
 679
 680 // static
 681 void ProcessManager::SetEventPageSuspendingTimeForTesting(
 682     unsigned suspending_time_msec) {
 683   g_event_page_suspending_time_msec = suspending_time_msec;
 684 }
 685
 686 void ProcessManager::Observe(int type,
 687                              const content::NotificationSource& source,
 688                              const content::NotificationDetails& details) {
 689   switch (type) {
 690     case extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED: {
 691       // TODO(jamescook): Convert this to use ExtensionSystem::ready() instead
 692       // of a notification.
 693       MaybeCreateStartupBackgroundHosts();
 694       break;
 695     }
 696
 697     case extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED: {
 698       BrowserContext* context = content::Source<BrowserContext>(source).ptr();
 699       ExtensionSystem* system = ExtensionSystem::Get(context);
 700       if (system->ready().is_signaled()) {
 701         // The extension system is ready, so create the background host.
 702         const Extension* extension =
 703             content::Details<const Extension>(details).ptr();
 704         CreateBackgroundHostForExtensionLoad(this, extension);
 705       }
 706       break;
 707     }
 708
 709     case extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED: {
 710       const Extension* extension =
 711           content::Details<UnloadedExtensionInfo>(details)->extension;
 712       for (ExtensionHostSet::iterator iter = background_hosts_.begin();
 713            iter != background_hosts_.end(); ++iter) {
 714         ExtensionHost* host = *iter;
 715         if (host->extension_id() == extension->id()) {
 716           CloseBackgroundHost(host);
 717           break;
 718         }
 719       }
 720       UnregisterExtension(extension->id());
 721       break;
 722     }
 723
 724     case extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED: {
 725       ExtensionHost* host = content::Details<ExtensionHost>(details).ptr();
 726       if (background_hosts_.erase(host)) {
 727         ClearBackgroundPageData(host->extension()->id());
 728         background_page_data_[host->extension()->id()].since_suspended.reset(
 729             new base::ElapsedTimer());
 730       }
 731       break;
 732     }
 733
 734     case extensions::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE: {
 735       ExtensionHost* host = content::Details<ExtensionHost>(details).ptr();
 736       if (host->extension_host_type() == VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
 737         CloseBackgroundHost(host);
 738       }
 739       break;
 740     }
 741
 742     case content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED: {
 743       // We get this notification both for new WebContents and when one
 744       // has its RenderViewHost replaced (e.g. when a user does a cross-site
 745       // navigation away from an extension URL). For the replaced case, we must
 746       // unregister the old RVH so it doesn't count as an active view that would
 747       // keep the event page alive.
 748       WebContents* contents = content::Source<WebContents>(source).ptr();
 749       if (contents->GetBrowserContext() != GetBrowserContext())
 750         break;
 751
 752       typedef std::pair<RenderViewHost*, RenderViewHost*> RVHPair;
 753       RVHPair* switched_details = content::Details<RVHPair>(details).ptr();
 754       if (switched_details->first)
 755         UnregisterRenderViewHost(switched_details->first);
 756
 757       // The above will unregister a RVH when it gets swapped out with a new
 758       // one. However we need to watch the WebContents to know when a RVH is
 759       // deleted because the WebContents has gone away.
 760       if (RegisterRenderViewHost(switched_details->second)) {
 761         RenderViewHostDestructionObserver::CreateForWebContents(contents);
 762       }
 763       break;
 764     }
 765
 766     case content::NOTIFICATION_WEB_CONTENTS_CONNECTED: {
 767       WebContents* contents = content::Source<WebContents>(source).ptr();
 768       if (contents->GetBrowserContext() != GetBrowserContext())
 769         break;
 770       const Extension* extension = GetExtensionForRenderViewHost(
 771           contents->GetRenderViewHost());
 772       if (!extension)
 773         return;
 774
 775       // RegisterRenderViewHost is called too early (before the process is
 776       // available), so we need to wait until now to notify.
 777       content::NotificationService::current()->Notify(
 778           extensions::NOTIFICATION_EXTENSION_VIEW_REGISTERED,
 779           content::Source<BrowserContext>(GetBrowserContext()),
 780           content::Details<RenderViewHost>(contents->GetRenderViewHost()));
 781       break;
 782     }
 783
 784     default:
 785       NOTREACHED();
 786   }
 787 }
 788
 789 void ProcessManager::OnDevToolsStateChanged(
 790     content::DevToolsAgentHost* agent_host,
 791     bool attached) {
 792   WebContents* web_contents = agent_host->GetWebContents();
 793   // Ignore unrelated notifications.
 794   if (!web_contents || web_contents->GetBrowserContext() != GetBrowserContext())
 795     return;
 796   if (GetViewType(web_contents) != VIEW_TYPE_EXTENSION_BACKGROUND_PAGE)
 797     return;
 798   const Extension* extension =
 799       GetExtensionForRenderViewHost(web_contents->GetRenderViewHost());
 800   if (!extension)
 801     return;
 802   if (attached) {
 803     // Keep the lazy background page alive while it's being inspected.
 804     CancelSuspend(extension);
 805     IncrementLazyKeepaliveCount(extension);
 806   } else {
 807     DecrementLazyKeepaliveCount(extension);
 808   }
 809 }
 810
 811 void ProcessManager::MaybeCreateStartupBackgroundHosts() {
 812   if (startup_background_hosts_created_)
 813     return;
 814
 815   // The embedder might disallow background pages entirely.
 816   ProcessManagerDelegate* delegate =
 817       ExtensionsBrowserClient::Get()->GetProcessManagerDelegate();
 818   if (delegate && !delegate->IsBackgroundPageAllowed(GetBrowserContext()))
 819     return;
 820
 821   // The embedder might want to defer background page loading. For example,
 822   // Chrome defers background page loading when it is launched to show the app
 823   // list, then triggers a load later when a browser window opens.
 824   if (delegate &&
 825       delegate->DeferCreatingStartupBackgroundHosts(GetBrowserContext()))
 826     return;
 827
 828   CreateStartupBackgroundHosts();
 829   startup_background_hosts_created_ = true;
 830
 831   // Background pages should only be loaded once. To prevent any further loads
 832   // occurring, we remove the notification listeners.
 833   BrowserContext* original_context =
 834       ExtensionsBrowserClient::Get()->GetOriginalContext(GetBrowserContext());
 835   if (registrar_.IsRegistered(
 836           this,
 837           extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
 838           content::Source<BrowserContext>(original_context))) {
 839     registrar_.Remove(this,
 840                       extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
 841                       content::Source<BrowserContext>(original_context));
 842   }
 843 }
 844
 845 void ProcessManager::CreateStartupBackgroundHosts() {
 846   DCHECK(!startup_background_hosts_created_);
 847   const ExtensionSet& enabled_extensions =
 848       extension_registry_->enabled_extensions();
 849   for (ExtensionSet::const_iterator extension = enabled_extensions.begin();
 850        extension != enabled_extensions.end();
 851        ++extension) {
 852     CreateBackgroundHostForExtensionLoad(this, extension->get());
 853
 854     FOR_EACH_OBSERVER(ProcessManagerObserver,
 855                       observer_list_,
 856                       OnBackgroundHostStartup(extension->get()));
 857   }
 858 }
 859
 860 void ProcessManager::OnBackgroundHostCreated(ExtensionHost* host) {
 861   DCHECK_EQ(GetBrowserContext(), host->browser_context());
 862   background_hosts_.insert(host);
 863
 864   if (BackgroundInfo::HasLazyBackgroundPage(host->extension())) {
 865     linked_ptr<base::ElapsedTimer> since_suspended(
 866         background_page_data_[host->extension()->id()].
 867             since_suspended.release());
 868     if (since_suspended.get()) {
 869       UMA_HISTOGRAM_LONG_TIMES("Extensions.EventPageIdleTime",
 870                                since_suspended->Elapsed());
 871     }
 872   }
 873 }
 874
 875 void ProcessManager::CloseBackgroundHost(ExtensionHost* host) {
 876   CHECK(host->extension_host_type() ==
 877         VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
 878   delete host;
 879   // |host| should deregister itself from our structures.
 880   CHECK(background_hosts_.find(host) == background_hosts_.end());
 881 }
 882
 883 void ProcessManager::UnregisterExtension(const std::string& extension_id) {
 884   // The lazy_keepalive_count may be greater than zero at this point because
 885   // RenderViewHosts are still alive. During extension reloading, they will
 886   // decrement the lazy_keepalive_count to negative for the new extension
 887   // instance when they are destroyed. Since we are erasing the background page
 888   // data for the unloaded extension, unregister the RenderViewHosts too.
 889   BrowserContext* context = GetBrowserContext();
 890   for (ExtensionRenderViews::iterator it = all_extension_views_.begin();
 891        it != all_extension_views_.end(); ) {
 892     if (GetExtensionID(it->first) == extension_id) {
 893       OnRenderViewHostUnregistered(context, it->first);
 894       all_extension_views_.erase(it++);
 895     } else {
 896       ++it;
 897     }
 898   }
 899
 900   background_page_data_.erase(extension_id);
 901 }
 902
 903 void ProcessManager::ClearBackgroundPageData(const std::string& extension_id) {
 904   background_page_data_.erase(extension_id);
 905
 906   // Re-register all RenderViews for this extension. We do this to restore
 907   // the lazy_keepalive_count (if any) to properly reflect the number of open
 908   // views.
 909   for (ExtensionRenderViews::const_iterator it = all_extension_views_.begin();
 910        it != all_extension_views_.end(); ++it) {
 911     if (GetExtensionID(it->first) == extension_id)
 912       IncrementLazyKeepaliveCountForView(it->first);
 913   }
 914 }
 915
 916 //
 917 // IncognitoProcessManager
 918 //
 919
 920 IncognitoProcessManager::IncognitoProcessManager(
 921     BrowserContext* incognito_context,
 922     BrowserContext* original_context,
 923     ProcessManager* original_manager,
 924     ExtensionRegistry* extension_registry)
 925     : ProcessManager(incognito_context, original_context, extension_registry),
 926       original_manager_(original_manager) {
 927   DCHECK(incognito_context->IsOffTheRecord());
 928
 929   // The original profile will have its own ProcessManager to
 930   // load the background pages of the spanning extensions. This process
 931   // manager need only worry about the split mode extensions, which is handled
 932   // in the NOTIFICATION_BROWSER_WINDOW_READY notification handler.
 933   registrar_.Remove(this,
 934                     extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
 935                     content::Source<BrowserContext>(original_context));
 936 }
 937
 938 bool IncognitoProcessManager::CreateBackgroundHost(const Extension* extension,
 939                                                    const GURL& url) {
 940   if (IncognitoInfo::IsSplitMode(extension)) {
 941     if (ExtensionsBrowserClient::Get()->IsExtensionIncognitoEnabled(
 942             extension->id(), GetBrowserContext()))
 943       return ProcessManager::CreateBackgroundHost(extension, url);
 944   } else {
 945     // Do nothing. If an extension is spanning, then its original-profile
 946     // background page is shared with incognito, so we don't create another.
 947   }
 948   return false;
 949 }
 950
 951 SiteInstance* IncognitoProcessManager::GetSiteInstanceForURL(const GURL& url) {
 952   const Extension* extension =
 953       extension_registry_->enabled_extensions().GetExtensionOrAppByURL(url);
 954   if (extension && !IncognitoInfo::IsSplitMode(extension))
 955     return original_manager_->GetSiteInstanceForURL(url);
 956
 957   return ProcessManager::GetSiteInstanceForURL(url);
 958 }
 959
 960 }  // namespace extensions