PipelineError is dead. Long live PipelineStatus!

webkit/glue/webmediaplayer_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 "webkit/glue/webmediaplayer_impl.h"
 
 #include <limits>
 
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 15 matching lines @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebVideoFrame.h"
 #include "webkit/glue/media/buffered_data_source.h"
 #include "webkit/glue/media/simple_data_source.h"
 #include "webkit/glue/media/video_renderer_impl.h"
 #include "webkit/glue/media/web_video_renderer.h"
 #include "webkit/glue/webvideoframe_impl.h"
 
 using WebKit::WebCanvas;
 using WebKit::WebRect;
 using WebKit::WebSize;
+using media::PipelineStatus;
 
 namespace {
 
 // Limits the maximum outstanding repaints posted on render thread.
 // This number of 50 is a guess, it does not take too much memory on the task
 // queue but gives up a pretty good latency on repaint.
 const int kMaxOutstandingRepaints = 50;
 
 // Limits the range of playback rate.
 //
@@ skipping 118 matching lines @@
   DCHECK(MessageLoop::current() == render_loop_);
   webmediaplayer_ = NULL;
   video_renderer_ = NULL;
 
   {
     base::AutoLock auto_lock(data_sources_lock_);
     data_sources_.clear();
   }
 }
 
-void WebMediaPlayerImpl::Proxy::PipelineInitializationCallback() {
-  render_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-      &WebMediaPlayerImpl::Proxy::PipelineInitializationTask));
+void WebMediaPlayerImpl::Proxy::PipelineInitializationCallback(
+    PipelineStatus status) {
+  render_loop_->PostTask(FROM_HERE, NewRunnableMethod(
+      this, &WebMediaPlayerImpl::Proxy::PipelineInitializationTask, status));
 }
 
-void WebMediaPlayerImpl::Proxy::PipelineSeekCallback() {
-  render_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-      &WebMediaPlayerImpl::Proxy::PipelineSeekTask));
+void WebMediaPlayerImpl::Proxy::PipelineSeekCallback(PipelineStatus status) {
+  render_loop_->PostTask(FROM_HERE, NewRunnableMethod(
+      this, &WebMediaPlayerImpl::Proxy::PipelineSeekTask, status));
 }
 
-void WebMediaPlayerImpl::Proxy::PipelineEndedCallback() {
-  render_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-      &WebMediaPlayerImpl::Proxy::PipelineEndedTask));
+void WebMediaPlayerImpl::Proxy::PipelineEndedCallback(PipelineStatus status) {
+  render_loop_->PostTask(FROM_HERE, NewRunnableMethod(
+      this, &WebMediaPlayerImpl::Proxy::PipelineEndedTask, status));
 }
 
-void WebMediaPlayerImpl::Proxy::PipelineErrorCallback() {
-  render_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-      &WebMediaPlayerImpl::Proxy::PipelineErrorTask));
+void WebMediaPlayerImpl::Proxy::PipelineErrorCallback(PipelineStatus error) {
+  DCHECK_NE(error, media::PIPELINE_OK);
+  render_loop_->PostTask(FROM_HERE, NewRunnableMethod(
+      this, &WebMediaPlayerImpl::Proxy::PipelineErrorTask, error));
 }
 
-void WebMediaPlayerImpl::Proxy::NetworkEventCallback() {
-  render_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-      &WebMediaPlayerImpl::Proxy::NetworkEventTask));
+void WebMediaPlayerImpl::Proxy::NetworkEventCallback(PipelineStatus status) {
+  render_loop_->PostTask(FROM_HERE, NewRunnableMethod(
+      this, &WebMediaPlayerImpl::Proxy::NetworkEventTask, status));
 }
 
 void WebMediaPlayerImpl::Proxy::AddDataSource(WebDataSource* data_source) {
   base::AutoLock auto_lock(data_sources_lock_);
   data_sources_.push_back(make_scoped_refptr(data_source));
 }
 
 void WebMediaPlayerImpl::Proxy::RepaintTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   {
     base::AutoLock auto_lock(lock_);
     --outstanding_repaints_;
     DCHECK_GE(outstanding_repaints_, 0);
   }
   if (webmediaplayer_) {
     webmediaplayer_->Repaint();
   }
 }
 
-void WebMediaPlayerImpl::Proxy::PipelineInitializationTask() {
+void WebMediaPlayerImpl::Proxy::PipelineInitializationTask(
+    PipelineStatus status) {
   DCHECK(MessageLoop::current() == render_loop_);
   if (webmediaplayer_) {
-    webmediaplayer_->OnPipelineInitialize();
+    webmediaplayer_->OnPipelineInitialize(status);
   }
 }
 
-void WebMediaPlayerImpl::Proxy::PipelineSeekTask() {
+void WebMediaPlayerImpl::Proxy::PipelineSeekTask(PipelineStatus status) {
   DCHECK(MessageLoop::current() == render_loop_);
   if (webmediaplayer_) {
-    webmediaplayer_->OnPipelineSeek();
+    webmediaplayer_->OnPipelineSeek(status);
   }
 }
 
-void WebMediaPlayerImpl::Proxy::PipelineEndedTask() {
+void WebMediaPlayerImpl::Proxy::PipelineEndedTask(PipelineStatus status) {
   DCHECK(MessageLoop::current() == render_loop_);
   if (webmediaplayer_) {
-    webmediaplayer_->OnPipelineEnded();
+    webmediaplayer_->OnPipelineEnded(status);
   }
 }
 
-void WebMediaPlayerImpl::Proxy::PipelineErrorTask() {
+void WebMediaPlayerImpl::Proxy::PipelineErrorTask(PipelineStatus error) {
   DCHECK(MessageLoop::current() == render_loop_);
   if (webmediaplayer_) {
-    webmediaplayer_->OnPipelineError();
+    webmediaplayer_->OnPipelineError(error);
   }
 }
 
-void WebMediaPlayerImpl::Proxy::NetworkEventTask() {
+void WebMediaPlayerImpl::Proxy::NetworkEventTask(PipelineStatus status) {
   DCHECK(MessageLoop::current() == render_loop_);
   if (webmediaplayer_) {
-    webmediaplayer_->OnNetworkEvent();
+    webmediaplayer_->OnNetworkEvent(status);
   }
 }
 
 void WebMediaPlayerImpl::Proxy::GetCurrentFrame(
     scoped_refptr<media::VideoFrame>* frame_out) {
   if (video_renderer_)
     video_renderer_->GetCurrentFrame(frame_out);
 }
 
 void WebMediaPlayerImpl::Proxy::PutCurrentFrame(
@@ skipping 479 matching lines @@
 void WebMediaPlayerImpl::WillDestroyCurrentMessageLoop() {
   Destroy();
   main_loop_ = NULL;
 }
 
 void WebMediaPlayerImpl::Repaint() {
   DCHECK(MessageLoop::current() == main_loop_);
   GetClient()->repaint();
 }
 
-void WebMediaPlayerImpl::OnPipelineInitialize() {
+void WebMediaPlayerImpl::OnPipelineInitialize(PipelineStatus status) {
   DCHECK(MessageLoop::current() == main_loop_);
-  if (pipeline_->GetError() == media::PIPELINE_OK) {
+  if (status == media::PIPELINE_OK) {
     // Only keep one time range starting from 0.
     WebKit::WebTimeRanges new_buffered(static_cast<size_t>(1));
     new_buffered[0].start = 0.0f;
     new_buffered[0].end =
         static_cast<float>(pipeline_->GetMediaDuration().InSecondsF());
     buffered_.swap(new_buffered);
 
     // Since we have initialized the pipeline, say we have everything otherwise
     // we'll remain either loading/idle.
     // TODO(hclam): change this to report the correct status.
     SetReadyState(WebKit::WebMediaPlayer::HaveMetadata);
     SetReadyState(WebKit::WebMediaPlayer::HaveEnoughData);
     if (pipeline_->IsLoaded()) {
       SetNetworkState(WebKit::WebMediaPlayer::Loaded);
     }
   } else {
-    // TODO(hclam): should use pipeline_->GetError() to determine the state
+    // TODO(hclam): should use |status| to determine the state
     // properly and reports error using MediaError.
     // WebKit uses FormatError to indicate an error for bogus URL or bad file.
     // Since we are at the initialization stage we can safely treat every error
     // as format error. Should post a task to call to |webmediaplayer_|.
     SetNetworkState(WebKit::WebMediaPlayer::FormatError);
   }
 
   // Repaint to trigger UI update.
   Repaint();
 }
 
-void WebMediaPlayerImpl::OnPipelineSeek() {
+void WebMediaPlayerImpl::OnPipelineSeek(PipelineStatus status) {
   DCHECK(MessageLoop::current() == main_loop_);
-  if (pipeline_->GetError() == media::PIPELINE_OK) {
+  if (status == media::PIPELINE_OK) {
     // Update our paused time.
     if (paused_) {
       paused_time_ = pipeline_->GetCurrentTime();
     }
 
     SetReadyState(WebKit::WebMediaPlayer::HaveEnoughData);
     seeking_ = false;
     GetClient()->timeChanged();
   }
 }
 
-void WebMediaPlayerImpl::OnPipelineEnded() {
+void WebMediaPlayerImpl::OnPipelineEnded(PipelineStatus status) {
   DCHECK(MessageLoop::current() == main_loop_);
-  if (pipeline_->GetError() == media::PIPELINE_OK) {
+  if (status == media::PIPELINE_OK) {
     GetClient()->timeChanged();
   }
 }
 
-void WebMediaPlayerImpl::OnPipelineError() {
+void WebMediaPlayerImpl::OnPipelineError(PipelineStatus error) {
   DCHECK(MessageLoop::current() == main_loop_);
-  switch (pipeline_->GetError()) {
+  switch (error) {
     case media::PIPELINE_OK:
+      LOG(DFATAL) << "PIPELINE_OK isn't an error!";
+      break;
+
     case media::PIPELINE_ERROR_INITIALIZATION_FAILED:
     case media::PIPELINE_ERROR_REQUIRED_FILTER_MISSING:
     case media::PIPELINE_ERROR_COULD_NOT_RENDER:
     case media::PIPELINE_ERROR_URL_NOT_FOUND:
     case media::PIPELINE_ERROR_NETWORK:
     case media::PIPELINE_ERROR_READ:
     case media::DEMUXER_ERROR_COULD_NOT_OPEN:
     case media::DEMUXER_ERROR_COULD_NOT_PARSE:
     case media::DEMUXER_ERROR_NO_SUPPORTED_STREAMS:
     case media::DEMUXER_ERROR_COULD_NOT_CREATE_THREAD:
@@ skipping 10 matching lines @@
     case media::PIPELINE_ERROR_INVALID_STATE:
       // Decode error.
       SetNetworkState(WebMediaPlayer::DecodeError);
       break;
   }
 
   // Repaint to trigger UI update.
   Repaint();
 }
 
-void WebMediaPlayerImpl::OnNetworkEvent() {
+void WebMediaPlayerImpl::OnNetworkEvent(PipelineStatus status) {
   DCHECK(MessageLoop::current() == main_loop_);
-  if (pipeline_->GetError() == media::PIPELINE_OK) {
+  if (status == media::PIPELINE_OK) {
     if (pipeline_->IsNetworkActive()) {
       SetNetworkState(WebKit::WebMediaPlayer::Loading);
     } else {
       // If we are inactive because we just finished receiving all the data,
       // do one final repaint to show final progress.
       if (bytesLoaded() == totalBytes() &&
           network_state_ != WebKit::WebMediaPlayer::Idle) {
         Repaint();
 
         SetNetworkState(WebKit::WebMediaPlayer::Loaded);
@@ skipping 39 matching lines @@
   message_loop_factory_.reset();
 
   // And then detach the proxy, it may live on the render thread for a little
   // longer until all the tasks are finished.
   if (proxy_) {
     proxy_->Detach();
     proxy_ = NULL;
   }
 }
 
-void WebMediaPlayerImpl::PipelineStoppedCallback() {
+void WebMediaPlayerImpl::PipelineStoppedCallback(PipelineStatus status) {

[acolwell GONE FROM CHROMIUM, 2011/03/15 23:43:55]

Could we replace the code that uses this with your new
PipelineStatusNotification object?

[Ami GONE FROM CHROMIUM, 2011/03/16 00:01:02]

Next CL.

   pipeline_stopped_.Signal();
 }
 
 WebKit::WebMediaPlayerClient* WebMediaPlayerImpl::GetClient() {
   DCHECK(MessageLoop::current() == main_loop_);
   DCHECK(client_);
   return client_;
 }
 
 }  // namespace webkit_glue