Extracted NetLog class's inner enum types into their own enum classes and

content/browser/download/download_file_impl.cc

 // Copyright (c) 2012 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 "content/browser/download/download_file_impl.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "content/browser/byte_stream.h"
 #include "content/browser/download/download_create_info.h"
 #include "content/browser/download/download_destination_observer.h"
 #include "content/browser/download/download_interrupt_reasons_impl.h"
 #include "content/browser/download/download_net_log_parameters.h"
 #include "content/browser/download/download_stats.h"
 #include "content/public/browser/browser_thread.h"
 #include "crypto/secure_hash.h"
 #include "crypto/sha2.h"
 #include "net/base/io_buffer.h"
+#include "net/log/net_log_event_type.h"
+#include "net/log/net_log_source_type.h"
 
 namespace content {
 
 const int kUpdatePeriodMs = 500;
 const int kMaxTimeBlockingFileThreadMs = 1000;
 
 // These constants control the default retry behavior for failing renames. Each
 // retry is performed after a delay that is twice the previous delay. The
 // initial delay is specified by kInitialRenameRetryDelayMs.
 const int kInitialRenameRetryDelayMs = 200;
 
 // Number of times a failing rename is retried before giving up.
 const int kMaxRenameRetries = 3;
 
 DownloadFileImpl::DownloadFileImpl(
     std::unique_ptr<DownloadSaveInfo> save_info,
     const base::FilePath& default_download_directory,
     std::unique_ptr<ByteStreamReader> stream,
     const net::BoundNetLog& download_item_net_log,
     base::WeakPtr<DownloadDestinationObserver> observer)
-    : bound_net_log_(net::BoundNetLog::Make(download_item_net_log.net_log(),
-                                            net::NetLog::SOURCE_DOWNLOAD_FILE)),
+    : bound_net_log_(
+          net::BoundNetLog::Make(download_item_net_log.net_log(),
+                                 net::NetLogSourceType::DOWNLOAD_FILE)),
       file_(bound_net_log_),
       save_info_(std::move(save_info)),
       default_download_directory_(default_download_directory),
       stream_reader_(std::move(stream)),
       bytes_seen_(0),
       observer_(observer),
       weak_factory_(this) {
   download_item_net_log.AddEvent(
-      net::NetLog::TYPE_DOWNLOAD_FILE_CREATED,
+      net::NetLogEventType::DOWNLOAD_FILE_CREATED,
       bound_net_log_.source().ToEventParametersCallback());
   bound_net_log_.BeginEvent(
-      net::NetLog::TYPE_DOWNLOAD_FILE_ACTIVE,
+      net::NetLogEventType::DOWNLOAD_FILE_ACTIVE,
       download_item_net_log.source().ToEventParametersCallback());
 }
 
 DownloadFileImpl::~DownloadFileImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
-  bound_net_log_.EndEvent(net::NetLog::TYPE_DOWNLOAD_FILE_ACTIVE);
+  bound_net_log_.EndEvent(net::NetLogEventType::DOWNLOAD_FILE_ACTIVE);
 }
 
 void DownloadFileImpl::Initialize(const InitializeCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   update_timer_.reset(new base::RepeatingTimer());
   DownloadInterruptReason result =
       file_.Initialize(save_info_->file_path,
                        default_download_directory_,
                        std::move(save_info_->file),
@@ skipping 250 matching lines @@
     std::unique_ptr<crypto::SecureHash> hash_state = file_.Finish();
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&DownloadDestinationObserver::DestinationCompleted,
                    observer_,
                    file_.bytes_so_far(),
                    base::Passed(&hash_state)));
   }
   if (bound_net_log_.IsCapturing()) {
-    bound_net_log_.AddEvent(
-        net::NetLog::TYPE_DOWNLOAD_STREAM_DRAINED,
-        base::Bind(&FileStreamDrainedNetLogCallback, total_incoming_data_size,
-                   num_buffers));
+    bound_net_log_.AddEvent(net::NetLogEventType::DOWNLOAD_STREAM_DRAINED,
+                            base::Bind(&FileStreamDrainedNetLogCallback,
+                                       total_incoming_data_size, num_buffers));
   }
 }
 
 void DownloadFileImpl::SendUpdate() {
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&DownloadDestinationObserver::DestinationUpdate,
                  observer_,
                  file_.bytes_so_far(),
                  rate_estimator_.GetCountPerSecond()));
 }
 
 DownloadFileImpl::RenameParameters::RenameParameters(
     RenameOption option,
     const base::FilePath& new_path,
     const RenameCompletionCallback& completion_callback)
     : option(option),
       new_path(new_path),
       retries_left(kMaxRenameRetries),
       completion_callback(completion_callback) {}
 
 DownloadFileImpl::RenameParameters::~RenameParameters() {}
 
 }  // namespace content