[Downloads] Deprecate incorrect metrics.

content/browser/download/download_request_core.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_request_core.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 184 matching lines @@
 
   DownloadRequestData::Attach(request.get(), params, download_id);
   return request;
 }
 
 DownloadRequestCore::DownloadRequestCore(net::URLRequest* request,
                                          Delegate* delegate)
     : delegate_(delegate),
       request_(request),
       download_id_(DownloadItem::kInvalidId),
-      last_buffer_size_(0),
       bytes_read_(0),
       pause_count_(0),
       was_deferred_(false),
       is_partial_request_(false),
       started_(false),
       abort_reason_(DOWNLOAD_INTERRUPT_REASON_NONE) {
   DCHECK(request_);
   DCHECK(delegate_);
   RecordDownloadCount(UNTHROTTLED_COUNT);
   power_save_blocker_.reset(new device::PowerSaveBlocker(
@@ skipping 11 matching lines @@
   } else {
     save_info_.reset(new DownloadSaveInfo);
   }
 }
 
 DownloadRequestCore::~DownloadRequestCore() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Remove output stream callback if a stream exists.
   if (stream_writer_)
     stream_writer_->RegisterCallback(base::Closure());
-
-  UMA_HISTOGRAM_TIMES("SB2.DownloadDuration",
-                      base::TimeTicks::Now() - download_start_time_);
 }
 
 std::unique_ptr<DownloadCreateInfo>
 DownloadRequestCore::CreateDownloadCreateInfo(DownloadInterruptReason result) {
   DCHECK(!started_);
   started_ = true;
   std::unique_ptr<DownloadCreateInfo> create_info(new DownloadCreateInfo(
       base::Time::Now(), request()->net_log(), std::move(save_info_)));
 
   if (result == DOWNLOAD_INTERRUPT_REASON_NONE)
@@ skipping 109 matching lines @@
 // Create a new buffer, which will be handed to the download thread for file
 // writing and deletion.
 bool DownloadRequestCore::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
                                      int* buf_size,
                                      int min_size) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(buf && buf_size);
   DCHECK(!read_buffer_.get());
 
   *buf_size = min_size < 0 ? kReadBufSize : min_size;
-  last_buffer_size_ = *buf_size;
   read_buffer_ = new net::IOBuffer(*buf_size);
   *buf = read_buffer_.get();
   return true;
 }
 
 // Pass the buffer to the download file writer.
 bool DownloadRequestCore::OnReadCompleted(int bytes_read, bool* defer) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(read_buffer_.get());
 
-  base::TimeTicks now(base::TimeTicks::Now());
-  if (!last_read_time_.is_null()) {
-    double seconds_since_last_read = (now - last_read_time_).InSecondsF();
-    if (now == last_read_time_)
-      // Use 1/10 ms as a "very small number" so that we avoid
-      // divide-by-zero error and still record a very high potential bandwidth.
-      seconds_since_last_read = 0.00001;
-
-    double actual_bandwidth = (bytes_read) / seconds_since_last_read;
-    double potential_bandwidth = last_buffer_size_ / seconds_since_last_read;
-    RecordBandwidth(actual_bandwidth, potential_bandwidth);
-  }
-  last_read_time_ = now;
-
   if (!bytes_read)
     return true;
   bytes_read_ += bytes_read;
   DCHECK(read_buffer_.get());
 
   // Take the data ship it down the stream.  If the stream is full, pause the
   // request; the stream callback will resume it.
   if (!stream_writer_->Write(read_buffer_, bytes_read)) {
     PauseRequest();
     *defer = was_deferred_ = true;
-    last_stream_pause_time_ = now;
+    last_stream_pause_time_ = base::TimeTicks::Now();
   }
 
   read_buffer_ = NULL;  // Drop our reference.
 
   if (pause_count_ > 0)
     *defer = was_deferred_ = true;
 
   return true;
 }
 
@@ skipping 220 matching lines @@
     return DOWNLOAD_INTERRUPT_REASON_NONE;
   }
 
   if (http_headers.response_code() == net::HTTP_PARTIAL_CONTENT)
     return DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT;
 
   return DOWNLOAD_INTERRUPT_REASON_NONE;
 }
 
 }  // namespace content