Bound the impact of system instability on chrome instability.

components/browser_watcher/system_session_analyzer_win.h

+// Copyright 2017 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 COMPONENTS_BROWSER_WATCHER_SYSTEM_SESSION_ANALYZER_WIN_H_
+#define COMPONENTS_BROWSER_WATCHER_SYSTEM_SESSION_ANALYZER_WIN_H_
+
+#include <map>
+#include <memory>
+#include <vector>
+
+#include "base/time/time.h"
+
+namespace browser_watcher {
+
+// Queries system logs for system session events.
+class SystemSessionEventFetcher {
+ public:
+  // Minimal information about a log event.
+  struct EventInfo {
+    uint16_t event_id;
+    base::Time event_time;
+  };
+
+  // Creates a SystemSessionEventFetcher that will query for events pertaining
+  // to the last session_cnt sessions.
+  explicit SystemSessionEventFetcher(uint32_t session_cnt);
+
+  // Queries for events pertaining to the last session_cnt sessions. On success,
+  // returns true and event_infos contains events ordered from newest to oldest.
+  // Returns false otherwise.
+  virtual bool FetchEvents(std::vector<EventInfo>* event_infos) const;
+
+ private:
+  uint32_t session_cnt_;
+
+  DISALLOW_COPY_AND_ASSIGN(SystemSessionEventFetcher);
+};
+
+// Analyzes system session events for unclean sessions.
+class SystemSessionAnalyzer {
+ public:
+  enum Status {
+    FAILED = 0,
+    CLEAN = 1,
+    UNCLEAN = 2,
+    OUTSIDE_RANGE = 3,
+  };
+
+  explicit SystemSessionAnalyzer(SystemSessionEventFetcher* fetcher);

[Sigurður Ásgeirsson, 2017/03/02 21:52:58]

If you (can) rearrange initialization, maybe it makes sense to just pass in the
map here?

[manzagop (departed), 2017/03/06 15:37:40]

As commented below, using lazy initialization as most of the time the query is
not
necessary.

+  virtual ~SystemSessionAnalyzer();
+
+  // Returns an analysis status for the system session that contains timestamp.
+  virtual Status IsSessionUnclean(base::Time timestamp);

[Sigurður Ásgeirsson, 2017/03/02 21:52:58]

looks like initialization here is implicit. Is there a good reason for this,
e.g. are you doing this because most of the time it'll never happen?
In that case, maybe you could mention this? If not, perhaps it's better to make
initialization explicit, so that you can record/report it explicitly?
EnsureInitialized() is an option...

[manzagop (departed), 2017/03/06 15:37:40]

That's correct: most of the time there will be no stability file and we won't 
need to query the system log. Expanded class comment.

+
+ private:
+  void Initialize();
+
+  SystemSessionEventFetcher* event_fetcher_;  // Not owned.
+
+  bool initialized_ = false;
+  bool init_success_ = false;
+
+  // Information about unclean sessions: start time to duration until the next
+  // session start, ie *not* session duration. Note: it's easier to get the
+  // delta to the next session start, and changes nothing wrt classiying
+  // events that occur during sessions assuming query timestamps fall within
+  // system sessions.
+  std::map<base::Time, base::TimeDelta> unclean_sessions_;
+
+  // Timestamp of the oldest event.
+  base::Time coverage_start_;
+
+  DISALLOW_COPY_AND_ASSIGN(SystemSessionAnalyzer);
+};
+
+}  // namespace browser_watcher
+
+#endif  // COMPONENTS_BROWSER_WATCHER_SYSTEM_SESSION_ANALYZER_WIN_H_