Re-open DevTools windows for PackagedApps if they are reloaded with DevTools open.

chrome/browser/extensions/shell_window_registry.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_SHELL_WINDOW_REGISTRY_H_
 #define CHROME_BROWSER_EXTENSIONS_SHELL_WINDOW_REGISTRY_H_
 
 #include <set>
 
 #include "base/compiler_specific.h"
 #include "base/memory/singleton.h"
 #include "base/observer_list.h"
 #include "chrome/browser/profiles/profile_keyed_service.h"
 #include "chrome/browser/profiles/profile_keyed_service_factory.h"
+#include "content/public/browser/notification_observer.h"
+#include "content/public/browser/notification_registrar.h"
 #include "ui/gfx/native_widget_types.h"
 
 class Profile;
 class ShellWindow;
 
 namespace content {
 class RenderViewHost;
 }
 
 namespace extensions {
 
 // The ShellWindowRegistry tracks the ShellWindows for all platform apps for a
 // particular profile.
 // This class is planned to evolve into tracking all PlatformApps for a
 // particular profile, with a PlatformApp encapsulating all views (background
 // page, shell windows, tray view, panels etc.) and other app level behaviour
 // (e.g. notifications the app is interested in, lifetime of the background
 // page).
-class ShellWindowRegistry : public ProfileKeyedService {
+class ShellWindowRegistry : public ProfileKeyedService,
+                            public content::NotificationObserver {
  public:
   class Observer {
    public:
     // Called just after a shell window was added.
     virtual void OnShellWindowAdded(ShellWindow* shell_window) = 0;
     // Called just after a shell window was removed.
     virtual void OnShellWindowRemoved(ShellWindow* shell_window) = 0;
 
    protected:
     virtual ~Observer() {}
   };
 
   typedef std::set<ShellWindow*> ShellWindowSet;
   typedef ShellWindowSet::const_iterator const_iterator;
+  typedef std::set<std::string> InspectedWindowSet;

[tapted, 2012/10/23 06:04:15]

this could be called InspectedWindowKeySet but that also sounds odd

 
-  ShellWindowRegistry();
+  explicit ShellWindowRegistry(Profile* profile);
   virtual ~ShellWindowRegistry();
 
   // Returns the instance for the given profile, or NULL if none. This is
   // a convenience wrapper around ShellWindowRegistry::Factory::GetForProfile.
   static ShellWindowRegistry* Get(Profile* profile);
 
   void AddShellWindow(ShellWindow* shell_window);
   void RemoveShellWindow(ShellWindow* shell_window);
 
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
   // Returns a set of windows owned by the application identified by app_id.
   ShellWindowSet GetShellWindowsForApp(const std::string& app_id) const;
   const ShellWindowSet& shell_windows() const { return shell_windows_; }
 
   // Helper functions to find shell windows with particular attributes.
   ShellWindow* GetShellWindowForRenderViewHost(
       content::RenderViewHost* render_view_host) const;
   ShellWindow* GetShellWindowForNativeWindow(gfx::NativeWindow window) const;
   // Returns an app window for the given app, or NULL if no shell windows are
   // open. If there is a window for the given app that is active, that one will
   // be returned, otherwise an arbitrary window will be returned.
   ShellWindow* GetCurrentShellWindowForApp(const std::string& app_id) const;
 
+  // Returns whether a ShellWindow's ID was last known to have a DevToolsAgent
+  // attached to it, which should be restored during a reload of a corresponding
+  // newly created |render_view_host|.
+  bool HadDevToolsAttached(content::RenderViewHost* render_view_host) const;

[benwells, 2012/10/23 06:18:48]

Where is the logic that tracks window positions to restore? Maybe this could go
there too?

[tapted, 2012/10/23 07:04:23]

It's in extensions::ShellWindowGeometryCache and accessed via

ShellWindowGeometryCache* ExtensionSystem::shell_window_geometry_cache()


One difference is that this cache is a thing persisted to disk, and read back
from disk at chrome launch, whereas ShellWindowRegistry is an ephemeral thing. I
think devtools "open" status should be ephemeral too. 

I only have a weak argument against it being a new, ephemeral part of
ShellWindowGeometryCache. An implementation in ShellWindowGeometryCache would
still have to use ShellWindowRegistry, since the "loaded" observer on the
DevToolsWindow only knows about the RenderViewHost that it's inspecting, and we
need ShellWindowRegistry to turn that into an extension+ShellWindow (and
ShellWindowGeometryCache doesn't use the registry currently). Also
ShellWindowRegistry's class comment seemed to fit ;-)

+
+ protected:
+  // content::NotificationObserver:
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE;
+
  private:
   class Factory : public ProfileKeyedServiceFactory {
    public:
     static ShellWindowRegistry* GetForProfile(Profile* profile);
 
     static Factory* GetInstance();
    private:
     friend struct DefaultSingletonTraits<Factory>;
 
     Factory();
     virtual ~Factory();
 
     // ProfileKeyedServiceFactory
     virtual ProfileKeyedService* BuildServiceInstanceFor(
         Profile* profile) const OVERRIDE;
     virtual bool ServiceHasOwnInstanceInIncognito() const OVERRIDE;
     virtual bool ServiceIsCreatedWithProfile() const OVERRIDE;
     virtual bool ServiceIsNULLWhileTesting() const OVERRIDE;
   };
 
   ShellWindowSet shell_windows_;
+  InspectedWindowSet inspected_windows_;
   ObserverList<Observer> observers_;
+  content::NotificationRegistrar registrar_;
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_SHELL_WINDOW_REGISTRY_H_