Add Promises for EME (Chromium side)

media/base/cdm_promise.h

+// Copyright 2014 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 MEDIA_BASE_CDM_PROMISE_H_
+#define MEDIA_BASE_CDM_PROMISE_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/callback.h"
+#include "media/base/media_export.h"
+#include "media/base/media_keys.h"
+
+namespace media {
+
+// Interface for promises being resolved/rejected in response to various
+// session actions. These may be called synchronously or asynchronously.
+// The promise must be resolved or rejected exactly once. It is expected that
+// the caller free the promise once it is resolved/rejected.
+//
+// This is only the base class, as parameter to resolve() varies.
+class MEDIA_EXPORT CdmPromise {
+ public:
+  typedef base::Callback<void(MediaKeys::Exception exception_code,
+                              uint32 system_code,
+                              const std::string& error_message)>
+      PromiseRejectedCB;
+
+  virtual ~CdmPromise();
+
+  // Used to indicate that the operation failed. |exception_code| must be
+  // specified. |system_code| is a Key System-specific value for the error
+  // that occurred, or 0 if there is no associated status code or such status
+  // codes are not supported by the Key System. |error_message| is optional.
+  virtual void reject(MediaKeys::Exception exception_code,
+                      uint32 system_code,
+                      const std::string& error_message);
+
+ protected:
+  CdmPromise();
+  CdmPromise(PromiseRejectedCB reject_cb);
+
+  PromiseRejectedCB reject_cb_;
+
+  // Keep track of whether the promise hasn't been resolved or rejected yet.
+  bool is_pending_;
+
+  DISALLOW_COPY_AND_ASSIGN(CdmPromise);
+};
+
+template <typename T>
+class MEDIA_EXPORT CdmPromiseTemplate : public CdmPromise {
+ public:
+  CdmPromiseTemplate(base::Callback<void(const T&)> resolve_cb,
+                     PromiseRejectedCB rejected_cb);
+  virtual ~CdmPromiseTemplate();
+  virtual void resolve(const T& result);
+
+ private:
+  base::Callback<void(const T&)> resolve_cb_;
+
+  DISALLOW_COPY_AND_ASSIGN(CdmPromiseTemplate);
+};
+
+// Specialization for no parameter to resolve().
+template <>
+class MEDIA_EXPORT CdmPromiseTemplate<void> : public CdmPromise {
+ public:
+  CdmPromiseTemplate(base::Callback<void(void)> resolve_cb,
+                     PromiseRejectedCB rejected_cb);
+  virtual ~CdmPromiseTemplate();
+  virtual void resolve();
+
+ protected:
+  CdmPromiseTemplate();

[xhwang, 2014/06/02 21:59:21]

hmm, how does this work? The copy constructor is still private? Shouldn't we
make the copy constructor protected? 

Also, add a comment why we have a protected copy ctor.

[xhwang, 2014/06/02 23:48:01]

Summary of offline discussion:

We need a default ctor because the SessionUpdatedPromise needs to inherit this
class but doesn't need any of it's implementation. The copy constructor (trying
to reuse the base's implementation) doesn't work well because the Promise that's
copied also needs to be fulfilled. We can set it's is_pending_ to be false when
we copy. But that also seems hacky. The root cause is that we are mixing the
interface and implementation. 

The "right" solution would be to create pure interfaces (e.g. CdmPromise and
CdmPromiseTemplate are pure interfaces), then have concrete implementations. But
that involves a lot of extra code only for this one application :( So I am okay
with the current approach, which is much simpler.

Please add some comments about why we need a default constructor. Thanks!

[jrummell, 2014/06/03 18:55:24]

Comment added.

+
+ private:
+  base::Callback<void(void)> resolve_cb_;
+
+  DISALLOW_COPY_AND_ASSIGN(CdmPromiseTemplate);
+};
+
+}  // namespace media
+
+#endif  // MEDIA_BASE_CDM_PROMISE_H_