Move ChromeNetLog to //components

components/net_log/net_log_temp_file.h

 // 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.
 
-#ifndef CHROME_BROWSER_NET_NET_LOG_TEMP_FILE_H_
-#define CHROME_BROWSER_NET_NET_LOG_TEMP_FILE_H_
+#ifndef COMPONENTS_NET_LOG_NET_LOG_TEMP_FILE_H_
+#define COMPONENTS_NET_LOG_NET_LOG_TEMP_FILE_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/threading/thread_checker.h"
 #include "net/log/net_log.h"
 
 namespace base {
 class DictionaryValue;
 }
 
 namespace net {
 class WriteToFileNetLogObserver;
 }
 
+namespace net_log {
+
 class ChromeNetLog;
 
 // NetLogTempFile logs all the NetLog entries into a temporary file
 // "chrome-net-export-log.json" created in base::GetTempDir() directory.
 //
 // NetLogTempFile maintains the current logging state (state_) and log file type
 // (log_type_) of the logging into a chrome-net-export-log.json file.
 //
 // The following are the possible states
 // a) Only Start is allowed (STATE_NOT_LOGGING, LOG_TYPE_NONE).
 // b) Only Stop is allowed (STATE_LOGGING).
 // c) Either Send or Start is allowed (STATE_NOT_LOGGING, anything but
 //    LOG_TYPE_NONE).
 //
 // This is created/destroyed on the UI thread, but all other function calls
 // occur on the FILE_USER_BLOCKING thread.
 //
 // This relies on the UI thread outlasting all other named threads for thread
 // safety.
 class NetLogTempFile {
  public:
   // This enum lists the UI button commands it could receive.
   enum Command {
     DO_START_LOG_BYTES,  // Call StartNetLog logging all bytes received.
-    DO_START,  // Call StartNetLog.
+    DO_START,            // Call StartNetLog.
     DO_START_STRIP_PRIVATE_DATA,  // Call StartNetLog stripping private data.
-    DO_STOP,   // Call StopNetLog.
+    DO_STOP,                      // Call StopNetLog.
   };
 
   virtual ~NetLogTempFile();
 
   // Accepts the button command and executes it.
   void ProcessCommand(Command command);
 
   // Returns true and the path to the temporary file. If there is no file to
   // send, then it returns false. It also returns false when actively logging to
   // the file.
   bool GetFilePath(base::FilePath* path);
 
   // Creates a Value summary of the state of the NetLogTempFile. The caller is
   // responsible for deleting the returned value.
   base::DictionaryValue* GetState();
 
  protected:
   // Constructs a NetLogTempFile. Only one instance is created in browser
   // process.
-  explicit NetLogTempFile(ChromeNetLog* chrome_net_log);
+  NetLogTempFile(ChromeNetLog* chrome_net_log,
+                 const std::string& channel_string);
 
   // Returns path name to base::GetTempDir() directory. Returns false if
   // base::GetTempDir() fails.
-  virtual bool GetNetExportLogBaseDirectory(
-      base::FilePath* path) const;
+  virtual bool GetNetExportLogBaseDirectory(base::FilePath* path) const;
 
  private:
   friend class ChromeNetLog;
   friend class NetLogTempFileTest;
 
   // Allow tests to access our innards for testing purposes.
   FRIEND_TEST_ALL_PREFIXES(NetLogTempFileTest, EnsureInitFailure);
   FRIEND_TEST_ALL_PREFIXES(NetLogTempFileTest, EnsureInitAllowStart);
   FRIEND_TEST_ALL_PREFIXES(NetLogTempFileTest, EnsureInitAllowStartOrSend);
   FRIEND_TEST_ALL_PREFIXES(NetLogTempFileTest, ProcessCommandDoStartAndStop);
@@ skipping 47 matching lines @@
 
   // Updates |log_path_| to be the base::FilePath to use for log files, which
   // will be inside the base::GetTempDir() directory. Returns false if
   // base::GetTempDir() fails, or unable to create a subdirectory for logging
   // withinh that directory.
   bool SetUpNetExportLogPath();
 
   // Returns true if a file exists at |log_path_|.
   bool NetExportLogExists() const;
 
+  base::ThreadChecker thread_checker_;
+
   // Helper function for unit tests.
   State state() const { return state_; }
   LogType log_type() const { return log_type_; }
 
-  State state_;  // Current state of NetLogTempFile.
+  State state_;       // Current state of NetLogTempFile.
   LogType log_type_;  // Type of current log file on disk.
 
   base::FilePath log_path_;  // base::FilePath to the temporary file.
 
   // |write_to_file_observer_| watches the NetLog event stream, and
   // sends all entries to the file created in StartNetLog().
   scoped_ptr<net::WriteToFileNetLogObserver> write_to_file_observer_;
 
   // The |chrome_net_log_| is owned by the browser process, cached here to avoid
   // using global (g_browser_process).
   ChromeNetLog* chrome_net_log_;
 
+  std::string channel_string_;
+
   DISALLOW_COPY_AND_ASSIGN(NetLogTempFile);
 };
 
-#endif  // CHROME_BROWSER_NET_NET_LOG_TEMP_FILE_H_
+}  // namespace net_log
+
+#endif  // COMPONENTS_NET_LOG_NET_LOG_TEMP_FILE_H_