Record keep alive registry's state in stability instrumentation

chrome/browser/lifetime/keep_alive_registry.cc

 // 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.
 
 #include "chrome/browser/lifetime/keep_alive_registry.h"
 
+#include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/lifetime/keep_alive_state_observer.h"
 #include "chrome/browser/lifetime/keep_alive_types.h"
 
+#if defined(OS_WIN)

[bcwhite, 2017/05/08 15:37:59]

Why do this only on Windows?

[manzagop (departed), 2017/05/08 16:12:59]

I recently re-jigged the build targets for reuse by the crashing scenario and
felt it was simpler to make all build targets windows only for now, instead of
dealing with the complexity of multiple platforms (figuring what's is_win and
what's not among the dependencies). I'm thinking we can change this once we
tackle the other platforms.

+#include "components/browser_watcher/stability_data_names.h"
+#include "components/browser_watcher/stability_debugging.h"
+#endif  // defined(OS_WIN)
+
 ////////////////////////////////////////////////////////////////////////////////
 // Public methods
 
 // static
 KeepAliveRegistry* KeepAliveRegistry::GetInstance() {
   return base::Singleton<KeepAliveRegistry>::get();
 }
 
 bool KeepAliveRegistry::IsKeepingAlive() const {
   return registered_count_ > 0;
@@ skipping 107 matching lines @@
 
   if (new_restart_allowed != old_restart_allowed)
     OnRestartAllowedChanged(new_restart_allowed);
 
   DVLOG(1) << "New state of the KeepAliveRegistry:" << *this;
 }
 
 void KeepAliveRegistry::OnKeepAliveStateChanged(bool new_keeping_alive) {
   DVLOG(1) << "Notifying KeepAliveStateObservers: KeepingAlive changed to: "
            << new_keeping_alive;
+#if defined(OS_WIN)
+  browser_watcher::SetStabilityDataBool(browser_watcher::kStabilityKeepAlive,
+                                        new_keeping_alive);
+#endif  // defined(OS_WIN)
   for (KeepAliveStateObserver& observer : observers_)
     observer.OnKeepAliveStateChanged(new_keeping_alive);
 }
 
 void KeepAliveRegistry::OnRestartAllowedChanged(bool new_restart_allowed) {
   DVLOG(1) << "Notifying KeepAliveStateObservers: Restart changed to: "
            << new_restart_allowed;
+#if defined(OS_WIN)
+  browser_watcher::SetStabilityDataBool(
+      browser_watcher::kStabilityRestartAllowed, new_restart_allowed);
+#endif  // defined(OS_WIN)
   for (KeepAliveStateObserver& observer : observers_)
     observer.OnKeepAliveRestartStateChanged(new_restart_allowed);
 }
 
 void KeepAliveRegistry::DecrementCount(KeepAliveOrigin origin,
                                        OriginMap* keep_alive_map) {
   int new_count = --keep_alive_map->at(origin);
   DCHECK_GE(keep_alive_map->at(origin), 0);
   if (new_count == 0)
     keep_alive_map->erase(origin);
 }
 
 std::ostream& operator<<(std::ostream& out, const KeepAliveRegistry& registry) {
   out << "{registered_count_=" << registry.registered_count_
       << ", restart_allowed_count_=" << registry.restart_allowed_count_
       << ", KeepAlives=[";
   for (auto counts_per_origin_it : registry.registered_keep_alives_) {
     if (counts_per_origin_it != *registry.registered_keep_alives_.begin())
       out << ", ";
     out << counts_per_origin_it.first << " (" << counts_per_origin_it.second
         << ")";
   }
   out << "]}";
   return out;
 }