1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_SESSIONS_SESSION_SERVICE_LOG_H_
#define CHROME_BROWSER_SESSIONS_SESSION_SERVICE_LOG_H_
#include <list>
#include "base/time/time.h"
class Profile;
namespace user_prefs {
class PrefRegistrySyncable;
}
// This file contains functionality used to track interesting session restore
// events. This is primarily aimed at helping understand whether session
// restore is failing.
//
// The appropriate code calls to the various log functions. This data is
// tracked in prefs, and only a limited amount of data is kept around.
// WARNING: these values are persisted to disk, do not change.
enum class SessionServiceEventLogType {
// The profile was started.
kStart = 0,
// A restore was triggered. Restore may be triggered more than once after
// a start.
kRestore = 1,
// The profile was shut down. It's still possible for a crash to happen
// after this. This is not logged if a crash happens before exit is attempted.
kExit = 2,
// An error in writing the file occurred. Multiple calls to AddEvent()
// when the last event is a error result in combining the event (this is
// done to ensure lots of write error don't spam the event log).
kWriteError = 3,
// Restore stopped because the Browser restore was going to restore to closed.
kRestoreCanceled = 4,
// A restore was initiated, meaning the browser will ask SessionService for
// the data to restore asynchronously.
kRestoreInitiated = 5,
kMinValue = kStart,
kMaxValue = kRestoreInitiated,
};
struct StartData {
// Whether the last run of chrome crashed.
bool did_last_session_crash;
};
struct RestoreData {
// The number of windows restored.
int window_count;
// The number of tabs restored.
int tab_count;
// Whether there was an error in reading the file contents.
bool encountered_error_reading;
};
struct ExitData {
// The number of windows open at the time of exit.
int window_count;
// The total number of tabs open at the time of exit.
int tab_count;
// True if this the first SessionService created for the Profile. False
// means the first SessionService was destroyed and a new one created.
bool is_first_session_service;
// True if at least one command was scheduled
bool did_schedule_command;
};
struct WriteErrorData {
// Number of write errors that occurred.
int error_count;
// Number of write errors that were unrecoverable. See SessionService for
// details on this.
int unrecoverable_error_count;
};
struct RestoreInitiatedData {
bool synchronous;
bool restore_browser;
};
union EventData {
StartData start;
RestoreData restore;
ExitData exit;
WriteErrorData write_error;
RestoreInitiatedData restore_initiated;
};
struct SessionServiceEvent {
SessionServiceEventLogType type;
base::Time time;
EventData data;
};
// Returns the most recent events, ordered with oldest event first. In general
// the times shouldn't be compared, as it's possible for bad clocks and/or
// timezone changes to cause an earlier event to have a later time.
std::list<SessionServiceEvent> GetSessionServiceEvents(Profile* profile);
void LogSessionServiceStartEvent(Profile* profile, bool after_crash);
void LogSessionServiceExitEvent(Profile* profile,
int window_count,
int tab_count,
bool is_first_session_service,
bool did_schedule_command);
void LogSessionServiceRestoreInitiatedEvent(Profile* profile,
bool synchronous,
bool restore_browser);
void LogSessionServiceRestoreEvent(Profile* profile,
int window_count,
int tab_count,
bool encountered_error_reading);
void LogSessionServiceRestoreCanceledEvent(Profile* profile);
void LogSessionServiceWriteErrorEvent(Profile* profile,
bool unrecoverable_write_error);
void RemoveLastSessionServiceEventOfType(Profile* profile,
SessionServiceEventLogType type);
void RegisterSessionServiceLogProfilePrefs(
user_prefs::PrefRegistrySyncable* registry);
// This function is used internally, and is generally only exposed for testing.
void LogSessionServiceEvent(Profile* profile, const SessionServiceEvent& event);
#endif // CHROME_BROWSER_SESSIONS_SESSION_SERVICE_LOG_H_
|
