Update Decryptor interface to support audio decoding.

media/filters/decrypting_video_decoder.cc

 // Copyright (c) 2012 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 "media/filters/decrypting_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/message_loop_proxy.h"
@@ skipping 50 matching lines @@
          state_ == kPendingDemuxerRead ||
          state_ == kPendingDecode ||
          state_ == kWaitingForKey ||
          state_ == kDecodeFinished) << state_;
   DCHECK(init_cb_.is_null());  // No Reset() during pending initialization.
   DCHECK(stop_cb_.is_null());  // No Reset() during pending Stop().
   DCHECK(reset_cb_.is_null());
 
   reset_cb_ = closure;
 
-  decryptor_->CancelDecryptAndDecodeVideo();
+  decryptor_->ResetDecoder(Decryptor::kVideo);
 
   // Reset() cannot complete if the read callback is still pending.
   // Defer the resetting process in this case. The |reset_cb_| will be fired
   // after the read callback is fired - see DoDecryptAndDecodeBuffer() and
   // DoDeliverFrame().
   if (state_ == kPendingDemuxerRead || state_ == kPendingDecode) {
     DCHECK(!read_cb_.is_null());
     return;
   }
 
@@ skipping 11 matching lines @@
   if (!message_loop_->BelongsToCurrentThread()) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &DecryptingVideoDecoder::Stop, this, closure));
     return;
   }
 
   DVLOG(2) << "Stop() - state: " << state_;
   DCHECK(stop_cb_.is_null());
   stop_cb_ = closure;
 
-  // We need to call Decryptor::StopVideoDecoder() if we ever called
-  // Decryptor::InitializeVideoDecoder() to cancel the pending initialization if
-  // the initialization is still pending, or to stop the video decoder if
-  // the initialization has completed.
+  // We need to call Decryptor::DeinitializeDecoder(Decryptor::kVideo) if we
+  // ever called Decryptor::InitializeVideoDecoder() to cancel the pending
+  // initialization if the initialization is still pending, or to stop the video
+  // decoder if the initialization has completed.
   // When the state is kUninitialized and kDecryptorRequested,
   // InitializeVideoDecoder() has not been called, so we are okay.
   // When the state is kStopped, the video decoder should have already been
-  // stopped, so no need to call StopVideoDecoder() either.
-  // In all other cases, we need to call StopVideoDecoder()!
+  // stopped, so no need to call DeinitializeDecoder(Decryptor::kVideo) either.
+  // In all other cases, we need to call DeinitializeDecoder(Decryptor::kVideo)!
   switch (state_) {
     case kUninitialized:
     case kStopped:
       DoStop();
       break;
     case kDecryptorRequested:
       // Stop() cannot complete if the decryptor request is still pending.
       // Defer the stopping process in this case. The |stop_cb_| will be fired
       // after the request decryptor callback is fired - see SetDecryptor().
       request_decryptor_notification_cb_.Run(DecryptorNotificationCB());
       break;
     case kIdle:
     case kDecodeFinished:
-      decryptor_->StopVideoDecoder();
+      decryptor_->DeinitializeDecoder(Decryptor::kVideo);

[ddorwin, 2012/10/17 02:52:33]

nit: Might be less bug-prone to have a private helper function. Just a thought.

[xhwang, 2012/10/17 22:29:06]

I'll hold here as fischman is trying to remove this part all together :)

       DoStop();
       break;
     case kWaitingForKey:
-      decryptor_->StopVideoDecoder();
+      decryptor_->DeinitializeDecoder(Decryptor::kVideo);
       DCHECK(!read_cb_.is_null());
       pending_buffer_to_decode_ = NULL;
       base::ResetAndReturn(&read_cb_).Run(kOk, NULL);
       DoStop();
       break;
     case kPendingDecoderInit:
     case kPendingDemuxerRead:
     case kPendingDecode:
       // Stop() cannot complete if the init or read callback is still pending.
       // Defer the stopping process in these cases. The |stop_cb_| will be
       // fired after the init or read callback is fired - see
       // FinishInitialization(), DoDecryptAndDecodeBuffer() and
       // DoDeliverFrame(), respectively.
-      decryptor_->StopVideoDecoder();
+      decryptor_->DeinitializeDecoder(Decryptor::kVideo);
       DCHECK(!init_cb_.is_null() || !read_cb_.is_null());
       break;
     default:
       NOTREACHED();
   }
 }
 
 DecryptingVideoDecoder::~DecryptingVideoDecoder() {
   DCHECK(state_ == kUninitialized || state_ == kStopped) << state_;
 }
@@ skipping 267 matching lines @@
 }
 
 void DecryptingVideoDecoder::DoStop() {
   DCHECK(init_cb_.is_null());
   DCHECK(read_cb_.is_null());
   state_ = kStopped;
   base::ResetAndReturn(&stop_cb_).Run();
 }
 
 }  // namespace media