Make DownloadHistory observe manager, items

content/browser/download/base_file.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/base_file.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 247 matching lines @@
       return LOG_ERROR("unable to create", net::ERR_FILE_NOT_FOUND);
     }
     full_path_ = temp_file;
   }
 
   return Open();
 }
 
 net::Error BaseFile::AppendDataToFile(const char* data, size_t data_len) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  DCHECK(!detached_);
+  if (detached_) return net::ERR_INVALID_HANDLE;

[Randy Smith (Not in Mondays), 2012/09/11 18:36:53]

You didn't respond on the other CL, so I'll ask again: Why this change?  It
seems like a very big behavioral change that goes against how I'd personally
like the class to behave.  Why?

[benjhayden, 2012/09/13 15:18:16]

I had found a race that meant that there might be an AppendDataToFile call after
Detach. I forget where the race was, so I'll try backing out this change and see
if it crops back up.

 
   // NOTE(benwells): The above DCHECK won't be present in release builds,
   // so we log any occurences to see how common this error is in the wild.
   if (detached_) {
     download_stats::RecordDownloadCount(
         download_stats::APPEND_TO_DETACHED_FILE_COUNT);
   }
 
   if (!file_stream_.get())
     return LOG_ERROR("get", net::ERR_INVALID_HANDLE);
@@ skipping 116 matching lines @@
   return Open();
 }
 
 void BaseFile::Detach() {
   detached_ = true;
   bound_net_log_.AddEvent(net::NetLog::TYPE_DOWNLOAD_FILE_DETACHED);
 }
 
 void BaseFile::Cancel() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  DCHECK(!detached_);
+  if (detached_) return;
 
   bound_net_log_.AddEvent(net::NetLog::TYPE_CANCELLED);
 
   Close();
 
   if (!full_path_.empty()) {
     bound_net_log_.AddEvent(net::NetLog::TYPE_DOWNLOAD_FILE_DELETED);
 
     file_util::Delete(full_path_, false);
   }
 }
 
 void BaseFile::Finish() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   if (calculate_hash_)
     secure_hash_->Finish(sha256_hash_, kSha256HashLen);
 
   Close();
 }
 
 bool BaseFile::GetHash(std::string* hash) {
-  DCHECK(!detached_);
+  if (detached_) return false;
   hash->assign(reinterpret_cast<const char*>(sha256_hash_),
                sizeof(sha256_hash_));
   return (calculate_hash_ && !in_progress());
 }
 
 std::string BaseFile::GetHashState() {
   if (!calculate_hash_)
     return "";
 
   Pickle hash_state;
@@ skipping 14 matching lines @@
   return secure_hash_->Deserialize(&data_iterator);
 }
 
 bool BaseFile::IsEmptyHash(const std::string& hash) {
   return (hash.size() == kSha256HashLen &&
           0 == memcmp(hash.data(), kEmptySha256Hash, sizeof(kSha256HashLen)));
 }
 
 void BaseFile::AnnotateWithSourceInformation() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  DCHECK(!detached_);
+  if (detached_) return;
 
 #if defined(OS_WIN)
   // Sets the Zone to tell Windows that this file comes from the internet.
   // We ignore the return value because a failure is not fatal.
   win_util::SetInternetZoneIdentifier(full_path_,
                                       UTF8ToWide(source_url_.spec()));
 #elif defined(OS_MACOSX)
   content::AddQuarantineMetadataToFile(full_path_, source_url_, referrer_url_);
   content::AddOriginMetadataToFile(full_path_, source_url_, referrer_url_);
 #elif defined(OS_LINUX)
@@ skipping 77 matching lines @@
   base::TimeDelta diff = current_time - start_tick_;
   int64 diff_ms = diff.InMilliseconds();
   return diff_ms == 0 ? 0 : bytes_so_far() * 1000 / diff_ms;
 }
 
 int64 BaseFile::CurrentSpeed() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   return CurrentSpeedAtTime(base::TimeTicks::Now());
 }