Fix about:flags information not showing up in chrome://net-export/ logs

components/net_log/net_log_file_writer_unittest.cc

 // Copyright (c) 2013 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 "components/net_log/net_log_file_writer.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 239 matching lines @@
 };
 
 class NetLogFileWriterTest : public ::testing::Test {
  public:
   using URLRequestContextGetterList =
       std::vector<scoped_refptr<net::URLRequestContextGetter>>;
 
   NetLogFileWriterTest()
       : net_log_(base::FilePath(),
                  net::NetLogCaptureMode::Default(),
-                 base::CommandLine::ForCurrentProcess()->GetCommandLineString(),
+                 base::CommandLine::StringType(),
                  kChannelString),
-        net_log_file_writer_(
-            &net_log_,
-            base::CommandLine::ForCurrentProcess()->GetCommandLineString(),
-            kChannelString),
+        net_log_file_writer_(&net_log_),
         file_thread_("NetLogFileWriter file thread"),
         net_thread_("NetLogFileWriter net thread") {}
 
   // ::testing::Test implementation
   void SetUp() override {
     ASSERT_TRUE(log_temp_dir_.CreateUniqueTempDir());
 
     // Override |net_log_file_writer_|'s default-log-base-directory-getter to
     // a getter that returns the temp dir created for the test.
     net_log_file_writer_.SetDefaultLogBaseDirectoryGetterForTest(
@@ skipping 54 matching lines @@
   }
 
   // If |custom_log_path| is empty path, |net_log_file_writer_| will use its
   // default log path, which is cached in |default_log_path_|.
   WARN_UNUSED_RESULT::testing::AssertionResult StartThenVerifyNewState(
       const base::FilePath& custom_log_path,
       net::NetLogCaptureMode capture_mode,
       const std::string& expected_capture_mode_string,
       const URLRequestContextGetterList& context_getters) {
     net_log_file_writer_.StartNetLog(custom_log_path, capture_mode,
-                                     context_getters);
+                                     base::CommandLine::StringType(),
+                                     kChannelString, context_getters);
     std::unique_ptr<base::DictionaryValue> state =
         test_state_observer_.WaitForNewState();
     ::testing::AssertionResult result =
         VerifyState(std::move(state), kStateStartingLogString);
     if (!result) {
       return ::testing::AssertionFailure()
              << "First state after StartNetLog() does not match expected:"
              << std::endl
              << result.message();
     }
@@ skipping 145 matching lines @@
   // For each capture mode, start and stop |net_log_file_writer_| in that mode.
   for (int i = 0; i < 3; ++i) {
     // StartNetLog(), should result in state change.
     ASSERT_TRUE(StartThenVerifyNewState(base::FilePath(), capture_modes[i],
                                         capture_mode_strings[i],
                                         URLRequestContextGetterList()));
 
     // Calling StartNetLog() again should be a no-op. Try doing StartNetLog()
     // with various capture modes; they should all be ignored and result in no
     // state change.
-    net_log_file_writer_.StartNetLog(base::FilePath(), capture_modes[i],
-                                     URLRequestContextGetterList());
-    net_log_file_writer_.StartNetLog(base::FilePath(),
-                                     capture_modes[(i + 1) % 3],
-                                     URLRequestContextGetterList());
-    net_log_file_writer_.StartNetLog(base::FilePath(),
-                                     capture_modes[(i + 2) % 3],
-                                     URLRequestContextGetterList());
+    net_log_file_writer_.StartNetLog(
+        base::FilePath(), capture_modes[i], base::CommandLine::StringType(),
+        kChannelString, URLRequestContextGetterList());
+    net_log_file_writer_.StartNetLog(
+        base::FilePath(), capture_modes[(i + 1) % 3],
+        base::CommandLine::StringType(), kChannelString,
+        URLRequestContextGetterList());
+    net_log_file_writer_.StartNetLog(
+        base::FilePath(), capture_modes[(i + 2) % 3],
+        base::CommandLine::StringType(), kChannelString,
+        URLRequestContextGetterList());
 
     // StopNetLog(), should result in state change. The capture mode should
     // match that of the first StartNetLog() call (called by
     // StartThenVerifyNewState()).
     ASSERT_TRUE(StopThenVerifyNewStateAndFile(
         base::FilePath(), nullptr, nullptr, capture_mode_strings[i]));
 
     // Stopping a second time should be a no-op.
     net_log_file_writer_.StopNetLog(nullptr, nullptr);
   }
@@ skipping 217 matching lines @@
 TEST_F(NetLogFileWriterTest, ReceiveStartWhileInitializing) {
   // Trigger initialization of |net_log_file_writer_|.
   net_log_file_writer_.Initialize(file_thread_.task_runner(),
                                   net_thread_.task_runner());
 
   // Before running the main message loop, tell |net_log_file_writer_| to start
   // logging. Not running the main message loop prevents the initialization
   // process from completing, so this ensures that StartNetLog() is received
   // before |net_log_file_writer_| finishes initialization, which means this
   // should be a no-op.
-  net_log_file_writer_.StartNetLog(base::FilePath(),
-                                   net::NetLogCaptureMode::Default(),
-                                   URLRequestContextGetterList());
+  net_log_file_writer_.StartNetLog(
+      base::FilePath(), net::NetLogCaptureMode::Default(),
+      base::CommandLine::StringType(), kChannelString,
+      URLRequestContextGetterList());
 
   // Now run the main message loop. Make sure StartNetLog() was ignored by
   // checking that the next two states are "initializing" followed by
   // "not-logging".
   std::unique_ptr<base::DictionaryValue> state =
       test_state_observer_.WaitForNewState();
   ASSERT_TRUE(VerifyState(std::move(state), kStateInitializingString));
   state = test_state_observer_.WaitForNewState();
   ASSERT_TRUE(
       VerifyState(std::move(state), kStateNotLoggingString, false, false, ""));
 }
 
 TEST_F(NetLogFileWriterTest, ReceiveStartWhileStoppingLog) {
   ASSERT_TRUE(InitializeThenVerifyNewState(true, false));
 
   // Call StartNetLog() on |net_log_file_writer_| and wait for the state change.
   ASSERT_TRUE(StartThenVerifyNewState(
       base::FilePath(), net::NetLogCaptureMode::IncludeSocketBytes(),
       kCaptureModeIncludeSocketBytesString, URLRequestContextGetterList()));
 
   // Tell |net_log_file_writer_| to stop logging.
   net_log_file_writer_.StopNetLog(nullptr, nullptr);
 
   // Before running the main message loop, tell |net_log_file_writer_| to start
   // logging. Not running the main message loop prevents the stopping process
   // from completing, so this ensures StartNetLog() is received before
   // |net_log_file_writer_| finishes stopping, which means this should be a
   // no-op.
-  net_log_file_writer_.StartNetLog(base::FilePath(),
-                                   net::NetLogCaptureMode::Default(),
-                                   URLRequestContextGetterList());
+  net_log_file_writer_.StartNetLog(
+      base::FilePath(), net::NetLogCaptureMode::Default(),
+      base::CommandLine::StringType(), kChannelString,
+      URLRequestContextGetterList());
 
   // Now run the main message loop. Make sure the last StartNetLog() was
   // ignored by checking that the next two states are "stopping-log" followed by
   // "not-logging". Also make sure the capture mode matches that of the first
   // StartNetLog() call (called by StartThenVerifyState()).
   std::unique_ptr<base::DictionaryValue> state =
       test_state_observer_.WaitForNewState();
   ASSERT_TRUE(VerifyState(std::move(state), kStateStoppingLogString));
   state = test_state_observer_.WaitForNewState();
   ASSERT_TRUE(VerifyState(std::move(state), kStateNotLoggingString, true, true,
                           kCaptureModeIncludeSocketBytesString));
 }
 
 }  // namespace net_log