Add TrackableCallback in ContentDecryptorDelegate.

content/renderer/pepper/content_decryptor_delegate.h

 // 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.
 
 #ifndef CONTENT_RENDERER_PEPPER_CONTENT_DECRYPTOR_DELEGATE_H_
 #define CONTENT_RENDERER_PEPPER_CONTENT_DECRYPTOR_DELEGATE_H_
 
 #include <queue>
 #include <string>
 
 #include "base/basictypes.h"
+#include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "media/base/decryptor.h"
 #include "media/base/media_keys.h"
 #include "media/base/sample_format.h"
 #include "ppapi/c/private/pp_content_decryptor.h"
 #include "ppapi/c/private/ppp_content_decryptor_private.h"
 #include "ui/gfx/size.h"
 
@@ skipping 75 matching lines @@
   void DecoderDeinitializeDone(PP_DecryptorStreamType decoder_type,
                                uint32_t request_id);
   void DecoderResetDone(PP_DecryptorStreamType decoder_type,
                         uint32_t request_id);
   void DeliverFrame(PP_Resource decrypted_frame,
                     const PP_DecryptedFrameInfo* frame_info);
   void DeliverSamples(PP_Resource audio_frames,
                       const PP_DecryptedSampleInfo* sample_info);
 
  private:
+  template <typename Callback>
+  class TrackableCallback {
+   public:
+    TrackableCallback() : id_(0u) {}
+    // TODO(xhwang): Check that no callback is pending in dtor.

[dmichael (off chromium), 2014/01/03 18:44:43]

That should be an easy check to add if you want it, right? Why not add it now?

[xhwang, 2014/01/07 19:53:31]

I can't do this now because we didn't always satisfy all callbacks, which is a
bug: https://codereview.chromium.org/116443009/

I'll address this TODO after that bug is fixed.

+    ~TrackableCallback() {};
+
+    bool Matches(uint32_t id) const { return id == id_; }
+
+    bool is_null() const { return cb_.is_null(); }
+
+    void Set(uint32_t id, const Callback& cb) {
+      DCHECK_EQ(id_, 0u);
+      DCHECK(cb_.is_null());
+      id_ = id;
+      cb_ = cb;
+    }
+
+    Callback ResetAndReturn() {
+      id_ = 0;
+      return base::ResetAndReturn(&cb_);
+    }
+
+   private:
+    uint32_t id_;
+    Callback cb_;
+  };
+
   // Cancels the pending decrypt-and-decode callback for |stream_type|.
   void CancelDecode(media::Decryptor::StreamType stream_type);
 
   // Fills |resource| with a PPB_Buffer_Impl and copies the data from
   // |encrypted_buffer| into the buffer resource. This method reuses
   // |audio_input_resource_| and |video_input_resource_| to reduce the latency
   // in requesting new PPB_Buffer_Impl resources. The caller must make sure that
   // |audio_input_resource_| or |video_input_resource_| is available before
   // calling this method.
   //
@@ skipping 30 matching lines @@
   media::SessionErrorCB session_error_cb_;
 
   gfx::Size natural_size_;
 
   // Request ID for tracking pending content decryption callbacks.
   // Note that zero indicates an invalid request ID.
   // TODO(xhwang): Add completion callbacks for Reset/Stop and remove the use
   // of request IDs.
   uint32_t next_decryption_request_id_;
 
-  uint32_t pending_audio_decrypt_request_id_;
-  media::Decryptor::DecryptCB pending_audio_decrypt_cb_;
-
-  uint32_t pending_video_decrypt_request_id_;
-  media::Decryptor::DecryptCB pending_video_decrypt_cb_;
-
-  uint32_t pending_audio_decoder_init_request_id_;
-  media::Decryptor::DecoderInitCB pending_audio_decoder_init_cb_;
-
-  uint32_t pending_video_decoder_init_request_id_;
-  media::Decryptor::DecoderInitCB pending_video_decoder_init_cb_;
-
-  uint32_t pending_audio_decode_request_id_;
-  media::Decryptor::AudioDecodeCB pending_audio_decode_cb_;
-
-  uint32_t pending_video_decode_request_id_;
-  media::Decryptor::VideoDecodeCB pending_video_decode_cb_;
+  TrackableCallback<media::Decryptor::DecryptCB> audio_decrypt_cb_;
+  TrackableCallback<media::Decryptor::DecryptCB> video_decrypt_cb_;
+  TrackableCallback<media::Decryptor::DecoderInitCB> audio_decoder_init_cb_;
+  TrackableCallback<media::Decryptor::DecoderInitCB> video_decoder_init_cb_;
+  TrackableCallback<media::Decryptor::AudioDecodeCB> audio_decode_cb_;
+  TrackableCallback<media::Decryptor::VideoDecodeCB> video_decode_cb_;
 
   // Cached audio and video input buffers. See MakeMediaBufferResource.
   scoped_refptr<PPB_Buffer_Impl> audio_input_resource_;
   scoped_refptr<PPB_Buffer_Impl> video_input_resource_;
 
   std::queue<uint32_t> free_buffers_;
 
   // Keep track of audio parameters.
   int audio_samples_per_second_;
   int audio_channel_count_;
 
   base::WeakPtr<ContentDecryptorDelegate> weak_this_;
   base::WeakPtrFactory<ContentDecryptorDelegate> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentDecryptorDelegate);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_PEPPER_CONTENT_DECRYPTOR_DELEGATE_H_