Remove DownloadItem::Is*() in favor of DI::GetState()

content/browser/download/download_item_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.
 
 // File method ordering: Methods in this file are in the same order as
 // in download_item_impl.h, with the following exception: The public
 // interface Start is placed in chronological order with the other
 // (private) routines that together define a DownloadItem's state
 // transitions as the download progresses.  See "Download progression
 // cascade" later in this file.
@@ skipping 458 matching lines @@
 
 bool DownloadItemImpl::IsPaused() const {
   return is_paused_;
 }
 
 bool DownloadItemImpl::IsTemporary() const {
   return is_temporary_;
 }
 
 bool DownloadItemImpl::CanResume() const {
-  if (IsInProgress() && IsPaused())
+  if ((GetState() == IN_PROGRESS) && IsPaused())
     return true;
 
   if (state_ != INTERRUPTED_INTERNAL)
     return false;
 
   // Downloads that don't have a WebContents should still be resumable, but this
   // isn't currently the case. See ResumeInterruptedDownload().
   if (!GetWebContents())
     return false;
 
@@ skipping 19 matching lines @@
     case RESUMING_INTERNAL:
       return false;
 
     case MAX_DOWNLOAD_INTERNAL_STATE:
       break;
   }
   NOTREACHED();
   return true;
 }
 
-bool DownloadItemImpl::IsInProgress() const {
-  return InternalToExternalState(state_) == IN_PROGRESS;
-}
-
-bool DownloadItemImpl::IsCancelled() const {
-  return  InternalToExternalState(state_) == CANCELLED;
-}
-
-bool DownloadItemImpl::IsInterrupted() const {
-  return InternalToExternalState(state_) == INTERRUPTED;
-}
-
-bool DownloadItemImpl::IsComplete() const {
-  return InternalToExternalState(state_) == COMPLETE;
-}
-
 const GURL& DownloadItemImpl::GetURL() const {
   return url_chain_.empty() ? GURL::EmptyGURL() : url_chain_.back();
 }
 
 const std::vector<GURL>& DownloadItemImpl::GetUrlChain() const {
   return url_chain_;
 }
 
 const GURL& DownloadItemImpl::GetOriginalUrl() const {
   // Be careful about taking the front() of possibly-empty vectors!
@@ skipping 151 matching lines @@
 bool DownloadItemImpl::CanShowInFolder() {
   // A download can be shown in the folder if the downloaded file is in a known
   // location.
   return CanOpenDownload() && !GetFullPath().empty();
 }
 
 bool DownloadItemImpl::CanOpenDownload() {
   // We can open the file or mark it for opening on completion if the download
   // is expected to complete successfully. Exclude temporary downloads, since
   // they aren't owned by the download system.
-  return (!IsDone() || IsComplete()) && !IsTemporary() &&
+  const bool isComplete = GetState() == DownloadItem::COMPLETE;

[benjhayden, 2013/06/13 19:01:45]

use hacker_style for variable names: is_complete

+  return (!IsDone() || isComplete) && !IsTemporary() &&
          !file_externally_removed_;
 }
 
 bool DownloadItemImpl::ShouldOpenFileBasedOnExtension() {
   return delegate_->ShouldOpenFileBasedOnExtension(GetTargetFilePath());
 }
 
 bool DownloadItemImpl::GetOpenWhenComplete() const {
   return open_when_complete_;
 }
@@ skipping 220 matching lines @@
   end_time_ = base::Time::Now();
   TransitionTo(COMPLETE_INTERNAL);
 }
 void DownloadItemImpl::DestinationUpdate(int64 bytes_so_far,
                                          int64 bytes_per_sec,
                                          const std::string& hash_state) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   VLOG(20) << __FUNCTION__ << " so_far=" << bytes_so_far
            << " per_sec=" << bytes_per_sec << " download=" << DebugString(true);
 
-  if (!IsInProgress()) {
+  if (GetState() != IN_PROGRESS) {
     // Ignore if we're no longer in-progress.  This can happen if we race a
     // Cancel on the UI thread with an update on the FILE thread.
     //
     // TODO(rdsmith): Arguably we should let this go through, as this means
     // the download really did get further than we know before it was
     // cancelled.  But the gain isn't very large, and the code is more
     // fragile if it has to support in progress updates in a non-in-progress
     // state.  This issue should be readdressed when we revamp performance
     // reporting.
     return;
@@ skipping 21 matching lines @@
   // has completed and the intermediate file has been renamed to simplify
   // resumption conditions.
   if (current_path_.empty() || target_path_.empty())
     destination_error_ = reason;
   else
     Interrupt(reason);
 }
 
 void DownloadItemImpl::DestinationCompleted(const std::string& final_hash) {
   VLOG(20) << __FUNCTION__ << " download=" << DebugString(true);
-  if (!IsInProgress())
+  if (GetState() != IN_PROGRESS)
     return;
   OnAllDataSaved(final_hash);
   MaybeCompleteDownload();
 }
 
 // **** Download progression cascade
 
 void DownloadItemImpl::Init(bool active,
                             DownloadType download_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 34 matching lines @@
     scoped_ptr<DownloadFile> file,
     scoped_ptr<DownloadRequestHandleInterface> req_handle) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!download_file_.get());
   DCHECK(file.get());
   DCHECK(req_handle.get());
 
   download_file_ = file.Pass();
   request_handle_ = req_handle.Pass();
 
-  if (IsCancelled()) {
+  if (GetState() == CANCELLED) {
     // The download was in the process of resuming when it was cancelled. Don't
     // proceed.
     ReleaseDownloadFile(true);
     request_handle_->CancelRequest();
     return;
   }
 
   TransitionTo(IN_PROGRESS_INTERNAL);
 
   last_reason_ = DOWNLOAD_INTERRUPT_REASON_NONE;
@@ skipping 636 matching lines @@
     case RESUME_MODE_USER_CONTINUE:
       return "USER_CONTINUE";
     case RESUME_MODE_USER_RESTART:
       return "USER_RESTART";
   }
   NOTREACHED() << "Unknown resume mode " << mode;
   return "unknown";
 }
 
 }  // namespace content