media config: expand is_encrypted to a struct.

media/base/encryption_scheme.h

Index: media/base/encryption_scheme.h
diff --git a/media/base/encryption_scheme.h b/media/base/encryption_scheme.h
new file mode 100644
index 0000000000000000000000000000000000000000..2751e4745d2e30c1e1126534aa045d9a8d7e6156
--- /dev/null
+++ b/media/base/encryption_scheme.h
@@ -0,0 +1,80 @@
+// Copyright 2015 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_ENCRYPTION_SCHEME_H_
+#define MEDIA_BASE_ENCRYPTION_SCHEME_H_
+
+#include <stdint.h>
+
+#include "media/base/media_export.h"
+
+namespace media {
+
+// Specification of whether and how the stream is encrypted (in whole or part).
+class MEDIA_EXPORT EncryptionScheme {
+ public:
+  // Algorithm and mode used for encryption.
+  enum CipherMode {
+    kCipherModeNone,

[ddorwin, 2016/03/01 02:17:41]

If we make this kCipherModeUnencrypted, is that clearer and does that simplify
things, such as the constructor that takes a bool?

[dougsteed, 2016/03/02 18:07:53]

Done.

+    kCipherModeAesCtr,
+    kCipherModeDefault = kCipherModeAesCtr,
+    kCipherModeAesCbc,
+    kCipherModeMax = kCipherModeAesCbc
+  };
+
+  // V3 of the CENC standard adds pattern encryption, through two new
+  // protection schemes 'cens' (with AES-CTR) and 'cbcs' (with AES-CBC).
+  // The pattern applies only to the 'encrypted' part of the frame (as
+  // defined by the relevant subsample entries), and reduces further the
+  // actual encryption applied through a repeating pattern of (encrypt:skip)
+  // 16 byte blocks. For example, in a (1:9) pattern, the first block is
+  // encrypted, and the next nine are skipped. This pattern is applied
+  // repeatedly until the end of the last 16-byte block in the subsample.
+  // Any remaining bytes are left clear.
+  // If either or both of encrypt_blocks or skip_blocks is 0, pattern

[ddorwin, 2016/03/01 02:17:41]

Where do these values come from? Media? App? Internally based on something else?

Is there any value in tracking a non-zero value when the other is 0?

Is the default constructor necessary/useful? If not, perhaps we should _always_
track pass these values.

[dougsteed, 2016/03/02 18:07:52]

In general they will come from the media, but only for certain encryption
schemes. Having the default, which disables pattern encryption, is very useful
right now, as that is widely applicable to most formats. While there is no
specific value I can see right now in tracking a non-zero value when the other
is zero, that seems to best model the way it is defined in CENC v3 draft, and I
don't see any harm. 

+  // encryption is disabled.
+  class PatternSpec {
+   public:
+    PatternSpec();
+    PatternSpec(uint32_t encrypt_blocks, uint32_t skip_blocks);
+    ~PatternSpec();
+
+    bool Matches(const PatternSpec& other) const;
+
+    uint32_t encrypt_blocks() const { return encrypt_blocks_; }
+    uint32_t skip_blocks() const { return skip_blocks_; }
+
+    bool IsInEffect() const;
+
+   private:
+    uint32_t encrypt_blocks_;
+    uint32_t skip_blocks_;
+
+    // Allow copy and assignment.
+  };
+
+  EncryptionScheme();

[ddorwin, 2016/03/01 02:17:41]

// Same as CreateUnencrypted().

+  explicit EncryptionScheme(bool is_encrypted);

[ddorwin, 2016/03/01 02:17:41]

Does it make sense to specify `true` without passing a mode? Can we replace uses
of this with the next one?

[dougsteed, 2016/03/02 18:07:53]

Done.

+  explicit EncryptionScheme(CipherMode mode);

[ddorwin, 2016/03/01 02:17:41]

Do we need this one? Should we be explicit about requiring the pattern to be
specified?

If tests are the main reason for some of these, we can create a CreateForTests()
wrapper that the presubmit check will only allow to be called from test files
and keep the production code more explicit.

[dougsteed, 2016/03/02 18:07:52]

As mentioned above I think the default pattern (i.e. pattern disabled) is the
overwhelming use case right now, and in most cases pattern is not even defined
for the mode in use, so I don't see any need to keep saying that explicitly.

+  EncryptionScheme(CipherMode mode, const PatternSpec& pattern);
+  ~EncryptionScheme();
+  static EncryptionScheme unencrypted();

[ddorwin, 2016/03/01 02:17:41]

CreateUnencrypted? It at least needs to use CamelCase.

[dougsteed, 2016/03/02 18:07:52]

Changed it to Unencrypted.

+
+  void Initialize(CipherMode mode, const PatternSpec& pattern);

[ddorwin, 2016/03/01 02:17:41]

Do we need this?

[dougsteed, 2016/03/02 18:07:52]

Appears not.

+  bool Matches(const EncryptionScheme& other) const;
+
+  bool is_encrypted() const;

[ddorwin, 2016/03/01 02:17:41]

This might not be a simple accessor anymore.

[dougsteed, 2016/03/02 18:07:52]

Not sure what you mean by that. It is very simple, just tests whether mode is
kCipherModeUnencrypted. I think it justifies being considered simple accessor.

+  CipherMode mode() const { return mode_; }
+  const PatternSpec& pattern() const { return pattern_; }
+
+ private:
+  CipherMode mode_;
+  PatternSpec pattern_;
+
+  // Allow copy and assignment.
+};
+
+}  // namespace media
+
+#endif  // MEDIA_BASE_ENCRYPTION_SCHEME_H_