Move ChromeNetLog to //components

components/net_log/net_log_temp_file_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 "chrome/browser/net/net_log_temp_file.h"
+#include "components/net_log/net_log_temp_file.h"
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/values.h"
 #include "build/build_config.h"
-#include "chrome/browser/net/chrome_net_log.h"
-#include "content/public/test/test_browser_thread.h"
+#include "components/net_log/chrome_net_log.h"
+#include "net/log/net_log_capture_mode.h"
 #include "net/log/write_to_file_net_log_observer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using content::BrowserThread;
+namespace {
+
+const char kChannelString[] = "SomeChannel";
+
+}  // namespace
+
+namespace net_log {
 
 class TestNetLogTempFile : public NetLogTempFile {
  public:
   explicit TestNetLogTempFile(ChromeNetLog* chrome_net_log)
-      : NetLogTempFile(chrome_net_log),
+      : NetLogTempFile(chrome_net_log, kChannelString),
         lie_about_net_export_log_directory_(false) {
     EXPECT_TRUE(net_log_temp_dir_.CreateUniqueTempDir());
   }
 
-  ~TestNetLogTempFile() override {
-    EXPECT_TRUE(net_log_temp_dir_.Delete());
-  }
+  ~TestNetLogTempFile() override { EXPECT_TRUE(net_log_temp_dir_.Delete()); }
 
   // NetLogTempFile implementation:
   bool GetNetExportLogBaseDirectory(base::FilePath* path) const override {
     if (lie_about_net_export_log_directory_)
       return false;
     *path = net_log_temp_dir_.path();
     return true;
   }
 
   void set_lie_about_net_export_log_directory(
       bool lie_about_net_export_log_directory) {
     lie_about_net_export_log_directory_ = lie_about_net_export_log_directory;
   }
 
  private:
   bool lie_about_net_export_log_directory_;
 
   base::ScopedTempDir net_log_temp_dir_;
 };
 
 class NetLogTempFileTest : public ::testing::Test {
  public:
   NetLogTempFileTest()
-      : net_log_(new ChromeNetLog),
-        net_log_temp_file_(new TestNetLogTempFile(net_log_.get())),
-        file_user_blocking_thread_(BrowserThread::FILE_USER_BLOCKING,
-                                   &message_loop_) {
+      : net_log_(new ChromeNetLog(base::FilePath(),
+                                  net::NetLogCaptureMode::Default(),
+                                  kChannelString)),
+        net_log_temp_file_(new TestNetLogTempFile(net_log_.get())) {
     EXPECT_TRUE(net_log_temp_file_->SetUpNetExportLogPath());
     net_export_log_ = net_log_temp_file_->log_path_;
   }
 
   std::string GetStateString() const {
     scoped_ptr<base::DictionaryValue> dict(net_log_temp_file_->GetState());
     std::string state;
     EXPECT_TRUE(dict->GetString("state", &state));
     return state;
   }
@@ skipping 25 matching lines @@
     std::string log;
     ASSERT_TRUE(ReadFileToString(net_export_log_, &log));
     base::JSONReader reader;
     scoped_ptr<base::Value> json = base::JSONReader::Read(log);
     EXPECT_TRUE(json);
   }
 
   // Verify state and GetFilePath return correct values if EnsureInit() fails.
   void VerifyFilePathAndStateAfterEnsureInitFailure() {
     EXPECT_EQ("UNINITIALIZED", GetStateString());
-    EXPECT_EQ(NetLogTempFile::STATE_UNINITIALIZED,
-              net_log_temp_file_->state());
+    EXPECT_EQ(NetLogTempFile::STATE_UNINITIALIZED, net_log_temp_file_->state());
 
     base::FilePath net_export_file_path;
     EXPECT_FALSE(net_log_temp_file_->GetFilePath(&net_export_file_path));
   }
 
   // When we lie in NetExportLogExists, make sure state and GetFilePath return
   // correct values.
   void VerifyFilePathAndStateAfterEnsureInit() {
     EXPECT_EQ("NOT_LOGGING", GetStateString());
     EXPECT_EQ(NetLogTempFile::STATE_NOT_LOGGING, net_log_temp_file_->state());
@@ skipping 78 matching lines @@
     EXPECT_EQ(expected_log_type_string, GetLogTypeString());
 
     base::FilePath net_export_file_path;
     EXPECT_TRUE(net_log_temp_file_->GetFilePath(&net_export_file_path));
     EXPECT_EQ(net_export_log_, net_export_file_path);
 
     VerifyNetExportLogComplete();
   }
 
   base::MessageLoop message_loop_;
-  content::TestBrowserThread file_user_blocking_thread_;
 };
 
 TEST_F(NetLogTempFileTest, EnsureInitFailure) {
   net_log_temp_file_->set_lie_about_net_export_log_directory(true);
 
   EXPECT_FALSE(net_log_temp_file_->EnsureInit());
   VerifyFilePathAndStateAfterEnsureInitFailure();
 
   net_log_temp_file_->ProcessCommand(NetLogTempFile::DO_START);
   VerifyFilePathAndStateAfterEnsureInitFailure();
@@ skipping 39 matching lines @@
   VerifyFileAndStateAfterDoStart();
 
   // Calling a second time should be a no-op.
   net_log_temp_file_->ProcessCommand(NetLogTempFile::DO_START);
   VerifyFileAndStateAfterDoStart();
 
   // starting with other log levels should also be no-ops.
   net_log_temp_file_->ProcessCommand(
       NetLogTempFile::DO_START_STRIP_PRIVATE_DATA);
   VerifyFileAndStateAfterDoStart();
-  net_log_temp_file_->ProcessCommand(
-      NetLogTempFile::DO_START_LOG_BYTES);
+  net_log_temp_file_->ProcessCommand(NetLogTempFile::DO_START_LOG_BYTES);
   VerifyFileAndStateAfterDoStart();
 
   net_log_temp_file_->ProcessCommand(NetLogTempFile::DO_STOP);
   VerifyFileAndStateAfterDoStop();
 
   // Calling DO_STOP second time should be a no-op.
   net_log_temp_file_->ProcessCommand(NetLogTempFile::DO_STOP);
   VerifyFileAndStateAfterDoStop();
 }
 
 TEST_F(NetLogTempFileTest,
        ProcessCommandDoStartAndStopWithPrivateDataStripping) {
   net_log_temp_file_->ProcessCommand(
       NetLogTempFile::DO_START_STRIP_PRIVATE_DATA);
   VerifyFileAndStateAfterDoStartStripPrivateData();
 
   // Calling a second time should be a no-op.
   net_log_temp_file_->ProcessCommand(
       NetLogTempFile::DO_START_STRIP_PRIVATE_DATA);
   VerifyFileAndStateAfterDoStartStripPrivateData();
 
   net_log_temp_file_->ProcessCommand(NetLogTempFile::DO_STOP);
   VerifyFileAndStateAfterDoStopWithStripPrivateData();
 
   // Calling DO_STOP second time should be a no-op.
   net_log_temp_file_->ProcessCommand(NetLogTempFile::DO_STOP);
   VerifyFileAndStateAfterDoStopWithStripPrivateData();
 }
 
-TEST_F(NetLogTempFileTest,
-       ProcessCommandDoStartAndStopWithByteLogging) {
+TEST_F(NetLogTempFileTest, ProcessCommandDoStartAndStopWithByteLogging) {
   net_log_temp_file_->ProcessCommand(NetLogTempFile::DO_START_LOG_BYTES);
   VerifyFileAndStateAfterDoStartLogBytes();
 
   // Calling a second time should be a no-op.
   net_log_temp_file_->ProcessCommand(NetLogTempFile::DO_START_LOG_BYTES);
   VerifyFileAndStateAfterDoStartLogBytes();
 
   net_log_temp_file_->ProcessCommand(NetLogTempFile::DO_STOP);
   VerifyFileAndStateAfterDoStopWithLogBytes();
 
@@ skipping 13 matching lines @@
 
   net_log_temp_file_->ProcessCommand(NetLogTempFile::DO_STOP);
   VerifyFileAndStateAfterDoStop();
 
   int64 stop_file_size;
   EXPECT_TRUE(base::GetFileSize(net_export_log_, &stop_file_size));
   EXPECT_GE(stop_file_size, start_file_size);
 
   // Add some junk at the end of the file.
   std::string junk_data("Hello");
-  EXPECT_TRUE(base::AppendToFile(net_export_log_, junk_data.c_str(),
-                                 junk_data.size()));
+  EXPECT_TRUE(
+      base::AppendToFile(net_export_log_, junk_data.c_str(), junk_data.size()));
 
   int64 junk_file_size;
   EXPECT_TRUE(base::GetFileSize(net_export_log_, &junk_file_size));
   EXPECT_GT(junk_file_size, stop_file_size);
 
   // Execute DO_START/DO_STOP commands and make sure the file is back to the
   // size before addition of junk data.
   net_log_temp_file_->ProcessCommand(NetLogTempFile::DO_START);
   VerifyFileAndStateAfterDoStart();
 
@@ skipping 30 matching lines @@
   // Log an event.
   net_log_->AddGlobalEntry(net::NetLog::TYPE_CANCELLED);
 
   net_log_temp_file_->ProcessCommand(NetLogTempFile::DO_STOP);
   VerifyFileAndStateAfterDoStop();
 
   int64 new_stop_file_size;
   EXPECT_TRUE(base::GetFileSize(net_export_log_, &new_stop_file_size));
   EXPECT_GE(new_stop_file_size, stop_file_size);
 }
+
+}  // namespace net_log