Renamed FilterHost::Error() and Pipeline::GetTime() to more appropriate names.

chrome/renderer/media/buffered_data_source.cc

 // Copyright (c) 2009 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 "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "chrome/common/extensions/url_pattern.h"
@@ skipping 524 matching lines @@
 void BufferedDataSource::Initialize(const std::string& url,
                                     media::FilterCallback* callback) {
   DCHECK(callback);
   initialize_callback_.reset(callback);
 
   // Save the url.
   url_ = GURL(url);
 
   // Make sure we support the scheme of the URL.
   if (!IsSchemeSupported(url_)) {
-    host()->Error(media::PIPELINE_ERROR_NETWORK);
+    host()->SetError(media::PIPELINE_ERROR_NETWORK);
     initialize_callback_->Run();
     initialize_callback_.reset();
     return;
   }
 
   media_format_.SetAsString(media::MediaFormat::kMimeType,
                             media::mime_type::kApplicationOctetStream);
   media_format_.SetAsString(media::MediaFormat::kURL, url);
 
   // Setup the BufferedResourceLoader here.
   scoped_refptr<BufferedResourceLoader> resource_loader = NULL;
   {
     AutoLock auto_lock(lock_);
     if (!stopped_) {
       buffered_resource_loader_ = new BufferedResourceLoader(
           render_loop_,
           bridge_factory_.get(),
           url_,
           kPositionNotSpecified,
           kPositionNotSpecified);
       resource_loader = buffered_resource_loader_;
     }
   }
 
   // Use the local reference to start the request.
   if (!resource_loader) {
-    host()->Error(media::PIPELINE_ERROR_NETWORK);
+    host()->SetError(media::PIPELINE_ERROR_NETWORK);
     initialize_callback_->Run();
     initialize_callback_.reset();
     return;
   }
 
   if (net::ERR_IO_PENDING != resource_loader->Start(
           NewCallback(this, &BufferedDataSource::InitialRequestStarted))) {
-    host()->Error(media::PIPELINE_ERROR_NETWORK);
+    host()->SetError(media::PIPELINE_ERROR_NETWORK);
     initialize_callback_->Run();
     initialize_callback_.reset();
   }
 }
 
 size_t BufferedDataSource::Read(uint8* data, size_t size) {
   // We try two times here:
   // 1. Use the existing resource loader to seek and read from it.
   // 2. If any of the above operations failed, we create a new resource loader
   //    starting with a new range. Goto 1.
@@ skipping 82 matching lines @@
   return false;
 }
 
 bool BufferedDataSource::IsSeekable() {
   return total_bytes_ != kPositionNotSpecified;
 }
 
 void BufferedDataSource::HandleError(media::PipelineError error) {
   AutoLock auto_lock(lock_);
   if (!stopped_) {
-    host()->Error(error);
+    host()->SetError(error);
   }
 }
 
 void BufferedDataSource::InitialRequestStarted(int error) {
   // Don't take any lock and call to |host_| here, this method is called from
   // BufferedResourceLoader after the response has started or failed, it is
   // very likely we are called within a lock in BufferedResourceLoader.
   // Acquiring an additional lock here we might have a deadlock situation,
   // but one thing very sure is that pipeline thread is still alive, so we
   // just need to post a task on that thread.
   pipeline_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this,
                         &BufferedDataSource::OnInitialRequestStarted, error));
 }
 
 void BufferedDataSource::OnInitialRequestStarted(int error) {
   // Acquiring a lock should not be needed because |stopped_| is only written
   // on pipeline thread and we are on pipeline thread but just to be safe.
   AutoLock auto_lock(lock_);
   if (!stopped_) {
     if (error == net::OK) {
       total_bytes_ = buffered_resource_loader_->content_length();
       if (IsSeekable()) {
         host()->SetTotalBytes(total_bytes_);
         // TODO(hclam): report the amount of bytes buffered accurately.
         host()->SetBufferedBytes(total_bytes_);
       }
     } else {
-      host()->Error(media::PIPELINE_ERROR_NETWORK);
+      host()->SetError(media::PIPELINE_ERROR_NETWORK);
     }
   }
   initialize_callback_->Run();
   initialize_callback_.reset();
 }
 
 const media::MediaFormat& BufferedDataSource::media_format() {
   return media_format_;
 }