Add KeepAliveStateObserver, add the Restart option

chrome/browser/lifetime/keep_alive_registry.h

 // Copyright 2016 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_LIFETIME_KEEP_ALIVE_REGISTRY_H_
 #define CHROME_BROWSER_LIFETIME_KEEP_ALIVE_REGISTRY_H_
 
 #include <set>
 
 #include "base/macros.h"
 #include "base/memory/singleton.h"
+#include "base/observer_list.h"
+#include "chrome/browser/lifetime/keep_alive_types.h"
 
 namespace keep_alive {
 enum class Origin;
+enum class RestartOption;
 }
+class KeepAliveStateObserver;
 
 class KeepAliveRegistry {
  public:
   static KeepAliveRegistry* GetInstance();
 
+  void AddObserver(KeepAliveStateObserver* observer);
+  void RemoveObserver(KeepAliveStateObserver* observer);
+
  private:
+  struct KeepAliveState {

[Bernhard Bauer, 2016/02/24 16:54:34]

Do you need this as a struct? It seems a bit easier to just split this up into
two members / parameters.

[dgn, 2016/02/24 19:08:32]

Makes it easier to use compute/compare state

+    bool is_keeping_alive;
+    keep_alive::RestartOption restart;

[Bernhard Bauer, 2016/02/24 16:54:34]

I'd be okay with keeping this as a boolean; I only want an enum for types that
are used as part of the public interface, but internally it's easier to keep
track of the interpretation of a boolean flag.

[dgn, 2016/02/24 19:08:32]

Thanks, I did it initially because I was comparing with KeepAliveOptions (RIP).
Not needed anymore.

+  };
+
   friend struct base::DefaultSingletonTraits<KeepAliveRegistry>;
   // Friend to be able to use Register/Unregister
   friend class ScopedKeepAlive;
 
   KeepAliveRegistry();
   ~KeepAliveRegistry();
 
   // Add/Remove entries. Do not use directly, use ScopedKeepAlive instead.
-  void Register(keep_alive::Origin origin);
-  void Unregister(keep_alive::Origin origin);
+  void Register(keep_alive::Origin origin, keep_alive::RestartOption restart);
+  void Unregister(keep_alive::Origin origin, keep_alive::RestartOption restart);
+
+  KeepAliveState ComputeCurrentState() const;
+  void NotifyOfStateDifferences(const KeepAliveState& previous_state);
+
+  void DumpRegistryIfDebug() const;
 
   std::multiset<keep_alive::Origin> registered_keep_alives_;
+  std::multiset<keep_alive::Origin> restart_allowed_keep_alives_;
+
+  KeepAliveState state_;

[Bernhard Bauer, 2016/02/24 16:54:34]

Hm... so, this is really defined by the two sets above. I think we could remove
this member in favor of always computing it from the canonical source. For state
transitions, you would then:

1) Calculate the old state, store locally
2) Modify state
3) Calculate the new state, store locally
4) Find out diff between old state and new state and notify observers about it.

[dgn, 2016/02/24 19:08:32]

Ok, I did that way in PS1 and ended up storing it to save a calculation.
Changing..

+
+  base::ObserverList<KeepAliveStateObserver> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(KeepAliveRegistry);
 };
 
 #endif  // CHROME_BROWSER_LIFETIME_KEEP_ALIVE_REGISTRY_H_