Adding callback support to media filter Initialize() and Seek().

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 514 matching lines @@
     stopped_ = true;
     resource_loader = buffered_resource_loader_;
     // Release the reference to the resource loader.
     buffered_resource_loader_ = NULL;
   }
   // Tell the loader to stop.
   if (resource_loader)
     resource_loader->Stop();
 }
 
-bool BufferedDataSource::Initialize(const std::string& url) {
+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);
-    return false;
+    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) {
-    if (net::ERR_IO_PENDING != resource_loader->Start(
-            NewCallback(this, &BufferedDataSource::InitialRequestStarted))) {
-      host()->Error(media::PIPELINE_ERROR_NETWORK);
-      return false;
-    }
-    return true;
+  if (!resource_loader) {
+    host()->Error(media::PIPELINE_ERROR_NETWORK);
+    initialize_callback_->Run();
+    initialize_callback_.reset();
+    return;
   }
-  host()->Error(media::PIPELINE_ERROR_NETWORK);
-  return false;
+
+  if (net::ERR_IO_PENDING != resource_loader->Start(
+          NewCallback(this, &BufferedDataSource::InitialRequestStarted))) {
+    host()->Error(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.
   for (size_t trials = kReadTrials; trials > 0; --trials) {
     scoped_refptr<BufferedResourceLoader> resource_loader = NULL;
     {
@@ skipping 96 matching lines @@
   // 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
+  // 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_);
       }
-      host()->InitializationComplete();
     } else {
       host()->Error(media::PIPELINE_ERROR_NETWORK);
     }
   }
+  initialize_callback_->Run();
+  initialize_callback_.reset();
 }
 
 const media::MediaFormat& BufferedDataSource::media_format() {
   return media_format_;
 }