[CrNet] Properly setup net log.

ios/crnet/crnet_environment.mm

 // Copyright 2014 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 "ios/crnet/crnet_environment.h"
 
 #import <Foundation/Foundation.h>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/files/scoped_file.h"
 #include "base/i18n/icu_util.h"
 #include "base/json/json_writer.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/scoped_block.h"
 #include "base/path_service.h"
 #include "base/threading/worker_pool.h"
 #import "components/webp_transcode/webp_network_client_factory.h"
 #include "crypto/nss_util.h"
 #include "ios/net/cookies/cookie_store_ios.h"
 #include "ios/net/crn_http_protocol_handler.h"
 #include "ios/net/request_tracker.h"
 #include "ios/web/public/user_agent.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/sdch_manager.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cert_net/nss_ocsp.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/http_stream_factory.h"
 #include "net/http/http_util.h"
+#include "net/log/net_log.h"
+#include "net/log/write_to_file_net_log_observer.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket/next_proto.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/default_channel_id_store.h"
 #include "net/ssl/ssl_config_service_defaults.h"
 #include "net/url_request/data_protocol_handler.h"
 #include "net/url_request/file_protocol_handler.h"
 #include "net/url_request/sdch_dictionary_fetcher.h"
 #include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_request_context_getter.h"
@@ skipping 102 matching lines @@
   // Create a message loop on the UI thread.
   base::MessageLoop* main_message_loop =
       new base::MessageLoop(base::MessageLoop::TYPE_UI);
 #pragma unused(main_message_loop)
   base::MessageLoopForUI::current()->Attach();
 }
 
 void CrNetEnvironment::StartNetLog(base::FilePath::StringType file_name,
     bool log_bytes) {
   DCHECK(file_name.length());
-  base::AutoLock lock(net_log_lock_);
-  if (net_log_started_) {
-    return;
-  }
-  net_log_started_ = true;
   PostToFileUserBlockingThread(FROM_HERE,
       base::Bind(&CrNetEnvironment::StartNetLogInternal,
                  base::Unretained(this), file_name, log_bytes));
 }
 
 void CrNetEnvironment::StartNetLogInternal(
     base::FilePath::StringType file_name, bool log_bytes) {
   DCHECK(base::MessageLoop::current() ==
          file_user_blocking_thread_->message_loop());
   DCHECK(file_name.length());
-  if (!net_log_.get()) {
-    net_log_.reset(new CrNetNetLog());
-    main_context_.get()->set_net_log(net_log_.get());
-  }
-  CrNetNetLog::Mode mode = log_bytes ? CrNetNetLog::LOG_ALL_BYTES :
-                                       CrNetNetLog::LOG_STRIP_PRIVATE_DATA;
-  net_log_->Start(base::FilePath(file_name), mode);
+  DCHECK(net_log_);
+
+  if (net_log_observer_)
+    return;
+
+  base::FilePath temp_dir;
+  if (!base::GetTempDir(&temp_dir))
+    return;
+
+  base::FilePath full_path = temp_dir.Append(file_name);
+  base::ScopedFILE file(base::OpenFile(full_path, "w"));
+  if (!file)
+    return;
+
+  net::NetLogCaptureMode capture_mode = log_bytes ?
+      net::NetLogCaptureMode::IncludeSocketBytes() :
+      net::NetLogCaptureMode::Default();
+
+  net_log_observer_.reset(new net::WriteToFileNetLogObserver());
+  net_log_observer_->set_capture_mode(capture_mode);
+  net_log_observer_->StartObserving(net_log_.get(), file.Pass(), nullptr,
+                                    nullptr);
 }
 
 void CrNetEnvironment::StopNetLog() {
-  base::AutoLock lock(net_log_lock_);
-  if (!net_log_started_) {
-    return;
-  }
-  net_log_started_ = false;
   PostToFileUserBlockingThread(FROM_HERE,
       base::Bind(&CrNetEnvironment::StopNetLogInternal,
       base::Unretained(this)));
 }
 
 void CrNetEnvironment::StopNetLogInternal() {
   DCHECK(base::MessageLoop::current() ==
          file_user_blocking_thread_->message_loop());
-  if (net_log_.get()) {
-    net_log_->Stop();
+  if (net_log_observer_) {
+    net_log_observer_->StopObserving(nullptr);
+    net_log_observer_.reset();
   }
 }
 
 void CrNetEnvironment::CloseAllSpdySessions() {
   PostToNetworkThread(FROM_HERE,
       base::Bind(&CrNetEnvironment::CloseAllSpdySessionsInternal,
       base::Unretained(this)));
 }
 
 void CrNetEnvironment::SetRequestFilterBlock(RequestFilterBlock block) {
@@ skipping 56 matching lines @@
       network_io_thread_->message_loop_proxy(), nullptr));
 
   PostToNetworkThread(FROM_HERE,
       base::Bind(&CrNetEnvironment::InitializeOnNetworkThread,
                  base::Unretained(this)));
 
   net::SetURLRequestContextForNSSHttpIO(main_context_.get());
   main_context_getter_ = new CrNetURLRequestContextGetter(
       main_context_.get(), network_io_thread_->message_loop_proxy());
   SetRequestFilterBlock(nil);
-  net_log_started_ = false;
 }
 
 void CrNetEnvironment::InstallIntoSessionConfiguration(
     NSURLSessionConfiguration* config) {
   config.protocolClasses = @[ [CRNHTTPProtocolHandler class] ];
 }
 
 CrNetEnvironment::~CrNetEnvironment() {
   net::HTTPProtocolHandlerDelegate::SetInstance(nullptr);
   net::SetURLRequestContextForNSSHttpIO(nullptr);
@@ skipping 132 matching lines @@
   scoped_refptr<net::CookieStore> cookie_store =
       net::CookieStoreIOS::CreateCookieStoreFromNSHTTPCookieStorage();
   main_context_->set_cookie_store(cookie_store.get());
 
   net::URLRequestJobFactoryImpl* job_factory =
       new net::URLRequestJobFactoryImpl;
   job_factory->SetProtocolHandler("data", new net::DataProtocolHandler);
   job_factory->SetProtocolHandler(
       "file", new net::FileProtocolHandler(file_thread_->message_loop_proxy()));
   main_context_->set_job_factory(job_factory);
+
+  net_log_.reset(new net::NetLog());
+  main_context_->set_net_log(net_log_.get());
 }
 
 std::string CrNetEnvironment::user_agent() {
   const net::HttpUserAgentSettings* user_agent_settings =
       main_context_->http_user_agent_settings();
   if (!user_agent_settings) {
     return nullptr;
   }
 
   return user_agent_settings->GetUserAgent();
@@ skipping 19 matching lines @@
       if (backend)
         backend->DoomAllEntries(client_callback);
   });
   int rc = cache->GetBackend(&backend, doom_callback);
   if (rc != net::ERR_IO_PENDING) {
     // GetBackend doesn't call the callback if it completes synchronously, so
     // call it directly here.
     doom_callback.Run(rc);
   }
 }