Fix bug with invalid chrome.sessions.onChanged listener.

chrome/browser/extensions/api/sessions/sessions_api.cc

 // Copyright 2013 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/api/sessions/sessions_api.h"
 
 #include <stddef.h>
 #include <utility>
 #include <vector>
 
@@ skipping 589 matching lines @@
   if (!session_id) {
     SetInvalidIdError(*params->session_id);
     return false;
   }
 
   return session_id->IsForeign() ?
       RestoreForeignSession(*session_id, browser)
       : RestoreLocalSession(*session_id, browser);
 }
 
-SessionsEventRouter::SessionsEventRouter(Profile* profile)
+SessionsEventRouter::SessionsEventRouter(Profile* profile,
+                                         EventRouter::Observer* observer)
     : profile_(profile),
+      observer_(observer),
       tab_restore_service_(TabRestoreServiceFactory::GetForProfile(profile)) {
   // TabRestoreServiceFactory::GetForProfile() can return NULL (i.e., when in
   // incognito mode)
   if (tab_restore_service_) {
     tab_restore_service_->LoadTabsFromLastSession();
     tab_restore_service_->AddObserver(this);
   }
 }
 
 SessionsEventRouter::~SessionsEventRouter() {
   if (tab_restore_service_)
     tab_restore_service_->RemoveObserver(this);
 }
 
 void SessionsEventRouter::TabRestoreServiceChanged(
     sessions::TabRestoreService* service) {
   scoped_ptr<base::ListValue> args(new base::ListValue());
   EventRouter::Get(profile_)->BroadcastEvent(make_scoped_ptr(
       new Event(events::SESSIONS_ON_CHANGED,
                 api::sessions::OnChanged::kEventName, std::move(args))));
 }
 
 void SessionsEventRouter::TabRestoreServiceDestroyed(
     sessions::TabRestoreService* service) {
   tab_restore_service_ = NULL;
+  EventRouter::Get(profile_)->RegisterObserver(
+      observer_, api::sessions::OnChanged::kEventName);
 }
 
 SessionsAPI::SessionsAPI(content::BrowserContext* context)
     : browser_context_(context) {
   EventRouter::Get(browser_context_)->RegisterObserver(this,
       api::sessions::OnChanged::kEventName);
 }
 
 SessionsAPI::~SessionsAPI() {
 }
 
 void SessionsAPI::Shutdown() {
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<SessionsAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 BrowserContextKeyedAPIFactory<SessionsAPI>*
 SessionsAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 void SessionsAPI::OnListenerAdded(const EventListenerInfo& details) {
   sessions_event_router_.reset(
-      new SessionsEventRouter(Profile::FromBrowserContext(browser_context_)));
+      new SessionsEventRouter(Profile::FromBrowserContext(browser_context_),

[Devlin, 2016/01/27 17:59:04]

This doesn't seem like the right solution... why do we create a brand new
SessionsEventRouter when the TabRestoreService is destroyed?  It seems like
we're listening to the wrong signal there.

[reat, 2016/01/28 04:09:59]

We do it because TabRestoreService is depends on profile, and while we create
window - create incognito window - close the first window, TabRestoreService is
destroyed, and there is no any possibility to have events on
sessions.onChanged().
Before this fix, when we try to register new event listener for new window, it
doesn't work because here we already remove listener (and do not register it
again), and already created SessionEventRouter doesn't work too, because old
TabRestoreService is destroyed, and SessionEventRouter is not subscribed for the
new one.

[Devlin, 2016/01/28 22:48:05]

Interesting.  This stems from TabRestoreService being a
BrowserContextKeyedService, but then modifying the lifetime to be destroyed
before the underling profile is destroyed.  sky@ happens to be an OWNER there -
sky, do you know why we prematurely destroy the TabRestoreService?  Do we need
to?

+                              this));
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 }  // namespace extensions