Convert some non-debug logging on content/common to debug logging.

content/common/net/url_fetcher_impl.cc

 // Copyright (c) 2011 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/common/net/url_fetcher_impl.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 316 matching lines @@
       file_message_loop_proxy_(file_message_loop_proxy),
       temp_file_handle_(base::kInvalidPlatformFileValue) {
 }
 
 URLFetcherImpl::Core::TempFileWriter::~TempFileWriter() {
   RemoveTempFile();
 }
 
 void URLFetcherImpl::Core::TempFileWriter::CreateTempFile() {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
-  CHECK(file_message_loop_proxy_.get());
+  DCHECK(file_message_loop_proxy_.get());
   base::FileUtilProxy::CreateTemporary(
       file_message_loop_proxy_,
       0,  // No additional file flags.
       base::Bind(&URLFetcherImpl::Core::TempFileWriter::DidCreateTempFile,
                  weak_factory_.GetWeakPtr()));
 }
 
 void URLFetcherImpl::Core::TempFileWriter::DidCreateTempFile(
     base::PlatformFileError error_code,
     base::PassPlatformFile file_handle,
@@ skipping 183 matching lines @@
 }
 
 URLFetcherImpl::Core::~Core() {
   // |request_| should be NULL.  If not, it's unsafe to delete it here since we
   // may not be on the IO thread.
   DCHECK(!request_.get());
 }
 
 void URLFetcherImpl::Core::Start() {
   DCHECK(delegate_loop_proxy_);
-  CHECK(request_context_getter_) << "We need an URLRequestContext!";
+  DCHECK(request_context_getter_) << "We need an URLRequestContext!";
   if (io_message_loop_proxy_) {
     DCHECK_EQ(io_message_loop_proxy_,
               request_context_getter_->GetIOMessageLoopProxy());
   } else {
     io_message_loop_proxy_ = request_context_getter_->GetIOMessageLoopProxy();
   }
-  CHECK(io_message_loop_proxy_.get()) << "We need an IO message loop proxy";
+  DCHECK(io_message_loop_proxy_.get()) << "We need an IO message loop proxy";
 
   io_message_loop_proxy_->PostTask(
       FROM_HERE, base::Bind(&Core::StartOnIOThread, this));
 }
 
 void URLFetcherImpl::Core::StartOnIOThread() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   switch (response_destination_) {
     case STRING:
@@ skipping 60 matching lines @@
   DCHECK(request_.get());
   DCHECK(!content.empty());
   request_->AppendChunkToUpload(content.data(),
                                 static_cast<int>(content.length()),
                                 is_last_chunk);
 }
 
 void URLFetcherImpl::Core::AppendChunkToUpload(const std::string& content,
                                            bool is_last_chunk) {
   DCHECK(delegate_loop_proxy_);
-  CHECK(io_message_loop_proxy_.get());
+  DCHECK(io_message_loop_proxy_.get());
   io_message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&Core::CompleteAddingUploadDataChunk, this, content,
                  is_last_chunk));
 }
 
 // Return true if the write was done and reading may continue.
 // Return false if the write is pending, and the next read will
 // be done later.
 bool URLFetcherImpl::Core::WriteBuffer(int num_bytes) {
@@ skipping 115 matching lines @@
 
 void URLFetcherImpl::Core::StartURLRequest() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (was_cancelled_) {
     // Since StartURLRequest() is posted as a *delayed* task, it may
     // run after the URLFetcher was already stopped.
     return;
   }
 
-  CHECK(request_context_getter_);
+  DCHECK(request_context_getter_);
   DCHECK(!request_.get());
 
   g_registry.Get().AddURLFetcherCore(this);
   request_.reset(new net::URLRequest(original_url_, this));
   int flags = request_->load_flags() | load_flags_;
   if (!g_interception_enabled) {
     flags = flags | net::LOAD_DISABLE_INTERCEPT;
   }
   if (is_chunked_upload_)
     request_->EnableChunkedUpload();
@@ skipping 27 matching lines @@
   }
 
   if (!extra_request_headers_.IsEmpty())
     request_->SetExtraRequestHeaders(extra_request_headers_);
 
   // There might be data left over from a previous request attempt.
   data_.clear();
 
   // If we are writing the response to a file, the only caller
   // of this function should have created it and not written yet.
-  CHECK(!temp_file_writer_.get() ||
-        temp_file_writer_->total_bytes_written() == 0);
+  DCHECK(!temp_file_writer_.get() ||
+         temp_file_writer_->total_bytes_written() == 0);
 
   request_->Start();
 }
 
 void URLFetcherImpl::Core::StartURLRequestWhenAppropriate() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (was_cancelled_)
     return;
 
@@ skipping 34 matching lines @@
   DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
 
   // Save the status and backoff_delay so that delegates can read it.
   if (delegate_) {
     backoff_delay_ = backoff_delay;
     InformDelegateFetchIsComplete();
   }
 }
 
 void URLFetcherImpl::Core::InformDelegateFetchIsComplete() {
-  CHECK(delegate_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
   if (delegate_) {
     delegate_->OnURLFetchComplete(fetcher_);
   }
 }
 
 void URLFetcherImpl::Core::NotifyMalformedContent() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   if (url_throttler_entry_ != NULL) {
     int status_code = response_code_;
     if (status_code == RESPONSE_CODE_INVALID) {
@@ skipping 225 matching lines @@
 
 // static
 content::URLFetcherFactory* URLFetcherImpl::factory() {
   return g_factory;
 }
 
 // static
 void URLFetcherImpl::set_factory(content::URLFetcherFactory* factory) {
   g_factory = factory;
 }