net_export_file_writer.cc 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355
  1. // Copyright (c) 2013 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "components/net_log/net_export_file_writer.h"
  5. #include <memory>
  6. #include <set>
  7. #include <utility>
  8. #include "base/bind.h"
  9. #include "base/callback.h"
  10. #include "base/callback_helpers.h"
  11. #include "base/files/file_path.h"
  12. #include "base/files/file_util.h"
  13. #include "base/files/scoped_file.h"
  14. #include "base/observer_list.h"
  15. #include "base/strings/utf_string_conversions.h"
  16. #include "base/task/sequenced_task_runner.h"
  17. #include "base/task/task_runner_util.h"
  18. #include "base/task/thread_pool.h"
  19. #include "base/threading/thread_task_runner_handle.h"
  20. #include "base/values.h"
  21. #include "build/build_config.h"
  22. #include "components/net_log/chrome_net_log.h"
  23. #include "services/network/public/mojom/network_context.mojom.h"
  24. namespace net_log {
  25. namespace {
  26. // Path of logs relative to default temporary directory given by
  27. // base::GetTempDir(). Must be kept in sync with
  28. // chrome/android/java/res/xml/file_paths.xml. Only used if not saving log file
  29. // to a custom path.
  30. const base::FilePath::CharType kLogRelativePath[] =
  31. FILE_PATH_LITERAL("net-export/chrome-net-export-log.json");
  32. // Contains file-related initialization tasks for NetExportFileWriter.
  33. NetExportFileWriter::DefaultLogPathResults SetUpDefaultLogPath(
  34. const NetExportFileWriter::DirectoryGetter& default_log_base_dir_getter) {
  35. NetExportFileWriter::DefaultLogPathResults results;
  36. results.default_log_path_success = false;
  37. results.log_exists = false;
  38. base::FilePath default_base_dir;
  39. if (!default_log_base_dir_getter.Run(&default_base_dir))
  40. return results;
  41. results.default_log_path = default_base_dir.Append(kLogRelativePath);
  42. if (!base::CreateDirectoryAndGetError(results.default_log_path.DirName(),
  43. nullptr))
  44. return results;
  45. results.log_exists = base::PathExists(results.default_log_path);
  46. results.default_log_path_success = true;
  47. return results;
  48. }
  49. base::FilePath GetPathIfExists(const base::FilePath& path) {
  50. if (!base::PathExists(path))
  51. return base::FilePath();
  52. return path;
  53. }
  54. scoped_refptr<base::SequencedTaskRunner> CreateFileTaskRunner() {
  55. // The tasks posted to this sequenced task runner do synchronous File I/O.
  56. //
  57. // These operations can be skipped on shutdown since FileNetLogObserver's API
  58. // doesn't require things to have completed until notified of completion.
  59. return base::ThreadPool::CreateSequencedTaskRunner(
  60. {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
  61. base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN});
  62. }
  63. } // namespace
  64. NetExportFileWriter::NetExportFileWriter()
  65. : state_(STATE_UNINITIALIZED),
  66. log_exists_(false),
  67. log_capture_mode_known_(false),
  68. log_capture_mode_(net::NetLogCaptureMode::kDefault),
  69. default_log_base_dir_getter_(base::BindRepeating(&base::GetTempDir)) {}
  70. NetExportFileWriter::~NetExportFileWriter() {
  71. if (net_log_exporter_) {
  72. net_log_exporter_->Stop(base::Value::Dict(), base::DoNothing());
  73. }
  74. }
  75. void NetExportFileWriter::AddObserver(StateObserver* observer) {
  76. DCHECK(thread_checker_.CalledOnValidThread());
  77. state_observer_list_.AddObserver(observer);
  78. }
  79. void NetExportFileWriter::RemoveObserver(StateObserver* observer) {
  80. DCHECK(thread_checker_.CalledOnValidThread());
  81. state_observer_list_.RemoveObserver(observer);
  82. }
  83. void NetExportFileWriter::Initialize() {
  84. DCHECK(thread_checker_.CalledOnValidThread());
  85. file_task_runner_ = CreateFileTaskRunner();
  86. if (state_ != STATE_UNINITIALIZED)
  87. return;
  88. state_ = STATE_INITIALIZING;
  89. NotifyStateObserversAsync();
  90. base::PostTaskAndReplyWithResult(
  91. file_task_runner_.get(), FROM_HERE,
  92. base::BindOnce(&SetUpDefaultLogPath, default_log_base_dir_getter_),
  93. base::BindOnce(&NetExportFileWriter::SetStateAfterSetUpDefaultLogPath,
  94. weak_ptr_factory_.GetWeakPtr()));
  95. }
  96. void NetExportFileWriter::StartNetLog(
  97. const base::FilePath& log_path,
  98. net::NetLogCaptureMode capture_mode,
  99. uint64_t max_file_size,
  100. const base::CommandLine::StringType& command_line_string,
  101. const std::string& channel_string,
  102. network::mojom::NetworkContext* network_context) {
  103. DCHECK(thread_checker_.CalledOnValidThread());
  104. DCHECK(file_task_runner_);
  105. if (state_ != STATE_NOT_LOGGING)
  106. return;
  107. if (!log_path.empty())
  108. log_path_ = log_path;
  109. DCHECK(!log_path_.empty());
  110. state_ = STATE_STARTING_LOG;
  111. NotifyStateObserversAsync();
  112. network_context->CreateNetLogExporter(
  113. net_log_exporter_.BindNewPipeAndPassReceiver());
  114. base::Value::Dict custom_constants =
  115. GetPlatformConstantsForNetLog(command_line_string, channel_string);
  116. net_log_exporter_.set_disconnect_handler(base::BindOnce(
  117. &NetExportFileWriter::OnConnectionError, base::Unretained(this)));
  118. base::PostTaskAndReplyWithResult(
  119. file_task_runner_.get(), FROM_HERE,
  120. base::BindOnce(&NetExportFileWriter::CreateOutputFile, log_path_),
  121. base::BindOnce(&NetExportFileWriter::StartNetLogAfterCreateFile,
  122. weak_ptr_factory_.GetWeakPtr(), capture_mode,
  123. max_file_size, std::move(custom_constants)));
  124. }
  125. void NetExportFileWriter::StartNetLogAfterCreateFile(
  126. net::NetLogCaptureMode capture_mode,
  127. uint64_t max_file_size,
  128. base::Value::Dict custom_constants,
  129. base::File output_file) {
  130. DCHECK(thread_checker_.CalledOnValidThread());
  131. DCHECK_EQ(STATE_STARTING_LOG, state_);
  132. // TODO(morlovich): Communicate file open trouble better
  133. // (https://crbug.com/838977)
  134. if (!output_file.IsValid()) {
  135. ResetExporterThenSetStateNotLogging();
  136. return;
  137. }
  138. // It's possible that the network service crashed in the window between
  139. // StartNetLog and here. In that case, OnConnectionError will have closed
  140. // |net_log_exporter_|.
  141. if (!net_log_exporter_)
  142. return;
  143. // base::Unretained(this) is safe here since |net_log_exporter_| is owned by
  144. // |this| and is a mojo InterfacePtr, which guarantees callback cancellation
  145. // upon its destruction.
  146. net_log_exporter_->Start(
  147. std::move(output_file), std::move(custom_constants), capture_mode,
  148. max_file_size,
  149. base::BindOnce(&NetExportFileWriter::OnStartResult,
  150. base::Unretained(this), capture_mode));
  151. }
  152. void NetExportFileWriter::OnStartResult(net::NetLogCaptureMode capture_mode,
  153. int result) {
  154. if (result == net::OK) {
  155. state_ = STATE_LOGGING;
  156. log_exists_ = true;
  157. log_capture_mode_known_ = true;
  158. log_capture_mode_ = capture_mode;
  159. NotifyStateObservers();
  160. } else {
  161. ResetExporterThenSetStateNotLogging();
  162. }
  163. }
  164. void NetExportFileWriter::StopNetLog(base::Value::Dict polled_data) {
  165. DCHECK(thread_checker_.CalledOnValidThread());
  166. if (state_ != STATE_LOGGING)
  167. return;
  168. state_ = STATE_STOPPING_LOG;
  169. NotifyStateObserversAsync();
  170. // base::Unretained(this) is safe here since |net_log_exporter_| is owned by
  171. // |this| and is a mojo InterfacePtr, which guarantees callback cancellation
  172. // upon its destruction.
  173. net_log_exporter_->Stop(std::move(polled_data),
  174. base::BindOnce(&NetExportFileWriter::OnStopResult,
  175. base::Unretained(this)));
  176. }
  177. void NetExportFileWriter::OnStopResult(int result) {
  178. ResetExporterThenSetStateNotLogging();
  179. }
  180. void NetExportFileWriter::OnConnectionError() {
  181. ResetExporterThenSetStateNotLogging();
  182. }
  183. base::Value::Dict NetExportFileWriter::GetState() const {
  184. DCHECK(thread_checker_.CalledOnValidThread());
  185. base::Value::Dict dict;
  186. dict.Set("file", base::UTF16ToUTF8(log_path_.LossyDisplayName()));
  187. base::StringPiece state_string;
  188. switch (state_) {
  189. case STATE_UNINITIALIZED:
  190. state_string = "UNINITIALIZED";
  191. break;
  192. case STATE_INITIALIZING:
  193. state_string = "INITIALIZING";
  194. break;
  195. case STATE_NOT_LOGGING:
  196. state_string = "NOT_LOGGING";
  197. break;
  198. case STATE_STARTING_LOG:
  199. state_string = "STARTING_LOG";
  200. break;
  201. case STATE_LOGGING:
  202. state_string = "LOGGING";
  203. break;
  204. case STATE_STOPPING_LOG:
  205. state_string = "STOPPING_LOG";
  206. break;
  207. }
  208. dict.Set("state", state_string);
  209. dict.Set("logExists", log_exists_);
  210. dict.Set("logCaptureModeKnown", log_capture_mode_known_);
  211. dict.Set("captureMode", CaptureModeToString(log_capture_mode_));
  212. return dict;
  213. }
  214. void NetExportFileWriter::GetFilePathToCompletedLog(
  215. FilePathCallback path_callback) const {
  216. DCHECK(thread_checker_.CalledOnValidThread());
  217. if (!(log_exists_ && state_ == STATE_NOT_LOGGING)) {
  218. base::ThreadTaskRunnerHandle::Get()->PostTask(
  219. FROM_HERE, base::BindOnce(std::move(path_callback), base::FilePath()));
  220. return;
  221. }
  222. DCHECK(file_task_runner_);
  223. DCHECK(!log_path_.empty());
  224. base::PostTaskAndReplyWithResult(file_task_runner_.get(), FROM_HERE,
  225. base::BindOnce(&GetPathIfExists, log_path_),
  226. std::move(path_callback));
  227. }
  228. std::string NetExportFileWriter::CaptureModeToString(
  229. net::NetLogCaptureMode capture_mode) {
  230. if (capture_mode == net::NetLogCaptureMode::kDefault)
  231. return "STRIP_PRIVATE_DATA";
  232. if (capture_mode == net::NetLogCaptureMode::kIncludeSensitive)
  233. return "NORMAL";
  234. if (capture_mode == net::NetLogCaptureMode::kEverything)
  235. return "LOG_BYTES";
  236. NOTREACHED();
  237. return "STRIP_PRIVATE_DATA";
  238. }
  239. net::NetLogCaptureMode NetExportFileWriter::CaptureModeFromString(
  240. const std::string& capture_mode_string) {
  241. if (capture_mode_string == "STRIP_PRIVATE_DATA")
  242. return net::NetLogCaptureMode::kDefault;
  243. if (capture_mode_string == "NORMAL")
  244. return net::NetLogCaptureMode::kIncludeSensitive;
  245. if (capture_mode_string == "LOG_BYTES")
  246. return net::NetLogCaptureMode::kEverything;
  247. NOTREACHED();
  248. return net::NetLogCaptureMode::kDefault;
  249. }
  250. void NetExportFileWriter::SetDefaultLogBaseDirectoryGetterForTest(
  251. const DirectoryGetter& getter) {
  252. default_log_base_dir_getter_ = getter;
  253. }
  254. void NetExportFileWriter::NotifyStateObservers() {
  255. DCHECK(thread_checker_.CalledOnValidThread());
  256. base::Value::Dict state = GetState();
  257. for (StateObserver& observer : state_observer_list_) {
  258. observer.OnNewState(state);
  259. }
  260. }
  261. void NetExportFileWriter::NotifyStateObserversAsync() {
  262. DCHECK(thread_checker_.CalledOnValidThread());
  263. base::ThreadTaskRunnerHandle::Get()->PostTask(
  264. FROM_HERE, base::BindOnce(&NetExportFileWriter::NotifyStateObservers,
  265. weak_ptr_factory_.GetWeakPtr()));
  266. }
  267. void NetExportFileWriter::SetStateAfterSetUpDefaultLogPath(
  268. const DefaultLogPathResults& set_up_default_log_path_results) {
  269. DCHECK(thread_checker_.CalledOnValidThread());
  270. DCHECK_EQ(STATE_INITIALIZING, state_);
  271. if (set_up_default_log_path_results.default_log_path_success) {
  272. state_ = STATE_NOT_LOGGING;
  273. log_path_ = set_up_default_log_path_results.default_log_path;
  274. log_exists_ = set_up_default_log_path_results.log_exists;
  275. DCHECK(!log_capture_mode_known_);
  276. } else {
  277. state_ = STATE_UNINITIALIZED;
  278. }
  279. NotifyStateObservers();
  280. }
  281. void NetExportFileWriter::ResetExporterThenSetStateNotLogging() {
  282. DCHECK(thread_checker_.CalledOnValidThread());
  283. net_log_exporter_.reset();
  284. state_ = STATE_NOT_LOGGING;
  285. NotifyStateObservers();
  286. }
  287. base::File NetExportFileWriter::CreateOutputFile(base::FilePath path) {
  288. return base::File(path,
  289. base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
  290. }
  291. } // namespace net_log