1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
// 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 <stdint.h>
#include <string>
#include "base/logging.h"
#include "base/macros.h"
// TODO(xhwang): Remove this include after http://crbug.com/656706 is fixed.
#include "media/base/content_decryption_module.h"
#include "media/base/media_export.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.
// These classes are almost generic, except for the parameters to reject(). If
// a generic class for promises is available, this could be changed to use the
// generic class as long as the parameters to reject() can be set appropriately.
// The base class only has a reject() method and GetResolveParameterType() that
// indicates the type of CdmPromiseTemplate. CdmPromiseTemplate<T> adds the
// resolve(T) method that is dependent on the type of promise. This base class
// is specified so that the promises can be easily saved before passing across
// the pepper interface.
class MEDIA_EXPORT CdmPromise {
public:
// TODO(jrummell): Remove deprecated errors. See
// http://crbug.com/570216
enum Exception {
NOT_SUPPORTED_ERROR,
INVALID_STATE_ERROR,
INVALID_ACCESS_ERROR,
QUOTA_EXCEEDED_ERROR,
UNKNOWN_ERROR,
CLIENT_ERROR,
OUTPUT_ERROR,
EXCEPTION_MAX = OUTPUT_ERROR
};
enum ResolveParameterType {
VOID_TYPE,
INT_TYPE,
STRING_TYPE,
KEY_IDS_VECTOR_TYPE
};
CdmPromise();
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(Exception exception_code,
uint32_t system_code,
const std::string& error_message) = 0;
// Used to determine the template type of CdmPromiseTemplate<T> so that
// saved CdmPromise objects can be cast to the correct templated version.
virtual ResolveParameterType GetResolveParameterType() const = 0;
private:
DISALLOW_COPY_AND_ASSIGN(CdmPromise);
};
// For some reason the Windows compiler is not happy with the implementation
// of CdmPromiseTemplate being in the .cc file, so moving it here.
template <typename... T>
struct CdmPromiseTraits {};
template <>
struct CdmPromiseTraits<> {
static const CdmPromise::ResolveParameterType kType = CdmPromise::VOID_TYPE;
};
template <>
struct CdmPromiseTraits<int> {
static const CdmPromise::ResolveParameterType kType = CdmPromise::INT_TYPE;
};
template <>
struct CdmPromiseTraits<std::string> {
static const CdmPromise::ResolveParameterType kType = CdmPromise::STRING_TYPE;
};
// This class adds the resolve(T) method. This class is still an interface, and
// is used as the type of promise that gets passed around.
template <typename... T>
class MEDIA_EXPORT CdmPromiseTemplate : public CdmPromise {
public:
CdmPromiseTemplate() : is_settled_(false) {}
virtual ~CdmPromiseTemplate() { DCHECK(is_settled_); }
virtual void resolve(const T&... result) = 0;
// CdmPromise implementation.
virtual void reject(Exception exception_code,
uint32_t system_code,
const std::string& error_message) = 0;
ResolveParameterType GetResolveParameterType() const override {
return CdmPromiseTraits<T...>::kType;
}
protected:
bool IsPromiseSettled() const { return is_settled_; }
// All implementations must call this method in resolve() and reject() methods
// to indicate that the promise has been settled.
void MarkPromiseSettled() {
// Promise can only be settled once.
DCHECK(!is_settled_);
is_settled_ = true;
}
// Must be called by the concrete destructor if !IsPromiseSettled().
// Note: We can't call reject() in ~CdmPromise() because reject() is virtual.
void RejectPromiseOnDestruction() {
DCHECK(!is_settled_);
std::string message =
"Unfulfilled promise rejected automatically during destruction.";
DVLOG(1) << message;
reject(INVALID_STATE_ERROR, 0, message);
DCHECK(is_settled_);
}
private:
// Keep track of whether the promise has been resolved or rejected yet.
bool is_settled_;
DISALLOW_COPY_AND_ASSIGN(CdmPromiseTemplate);
};
} // namespace media
#endif // MEDIA_BASE_CDM_PROMISE_H_
|
