Made MediaFilter::host_ and MediaFilter::message_loop_ private.

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 520 matching lines @@
   if (resource_loader)
     resource_loader->Stop();
 }
 
 bool BufferedDataSource::Initialize(const std::string& url) {
   // 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()->Error(media::PIPELINE_ERROR_NETWORK);
     return false;
   }
 
   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) {
     if (net::ERR_IO_PENDING != resource_loader->Start(
             NewCallback(this, &BufferedDataSource::InitialRequestStarted))) {
-      host_->Error(media::PIPELINE_ERROR_NETWORK);
+      host()->Error(media::PIPELINE_ERROR_NETWORK);
       return false;
     }
     return true;
   }
-  host_->Error(media::PIPELINE_ERROR_NETWORK);
+  host()->Error(media::PIPELINE_ERROR_NETWORK);
   return false;
 }
 
 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.
   for (size_t trials = kReadTrials; trials > 0; --trials) {
     scoped_refptr<BufferedResourceLoader> resource_loader = NULL;
@@ skipping 80 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()->Error(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_);
+        host()->SetTotalBytes(total_bytes_);
         // TODO(hclam): report the amount of bytes buffered accurately.
-        host_->SetBufferedBytes(total_bytes_);
+        host()->SetBufferedBytes(total_bytes_);
       }
-      host_->InitializationComplete();
+      host()->InitializationComplete();
     } else {
-      host_->Error(media::PIPELINE_ERROR_NETWORK);
+      host()->Error(media::PIPELINE_ERROR_NETWORK);
     }
   }
 }
 
 const media::MediaFormat& BufferedDataSource::media_format() {
   return media_format_;
 }