Plumb |use_secure_codecs| through to BrowserCdmFactoryAndroid.

media/cdm/proxy_decryptor.cc

 // Copyright 2013 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/cdm/proxy_decryptor.h"
 
 #include <cstring>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "media/base/cdm_callback_promise.h"
+#include "media/base/cdm_config.h"
 #include "media/base/cdm_factory.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/key_systems.h"
 #include "media/base/media_permission.h"
 #include "media/cdm/json_web_key.h"
 #include "media/cdm/key_system_names.h"
 
 namespace media {
 
 // Special system code to signal a closed persistent session in a SessionError()
@@ skipping 34 matching lines @@
 }
 
 void ProxyDecryptor::CreateCdm(CdmFactory* cdm_factory,
                                const std::string& key_system,
                                const GURL& security_origin,
                                const CdmContextReadyCB& cdm_context_ready_cb) {
   DVLOG(1) << __FUNCTION__ << ": key_system = " << key_system;
   DCHECK(!is_creating_cdm_);
   DCHECK(!media_keys_);
 
   // TODO(sandersd): Trigger permissions check here and use it to determine

[ddorwin, 2015/05/13 06:03:21]

What exactly needs to be done here? Do we need to move the permission request
from GKRInternal to here (earlier)? Perhaps update the comment.

[sandersd (OOO until July 31), 2015/05/14 00:06:57]

Yes, although there are synchronization issues we need to solve to do that. The
truth is that we will never do it, we'll just delete prefixed instead.

   // distinctive identifier support, instead of always requiring the
   // permission. http://crbug.com/455271
-  bool allow_distinctive_identifier = true;
-  bool allow_persistent_state = true;
+  CdmConfig cdm_config;
+  cdm_config.allow_distinctive_identifier = true;
+  cdm_config.allow_persistent_state = true;
 
   is_creating_cdm_ = true;
 
   base::WeakPtr<ProxyDecryptor> weak_this = weak_ptr_factory_.GetWeakPtr();
   cdm_factory->Create(
-      key_system, allow_distinctive_identifier, allow_persistent_state,
-      security_origin, base::Bind(&ProxyDecryptor::OnSessionMessage, weak_this),
+      key_system, security_origin, cdm_config,
+      base::Bind(&ProxyDecryptor::OnSessionMessage, weak_this),
       base::Bind(&ProxyDecryptor::OnSessionClosed, weak_this),
       base::Bind(&ProxyDecryptor::OnLegacySessionError, weak_this),
       base::Bind(&ProxyDecryptor::OnSessionKeysChange, weak_this),
       base::Bind(&ProxyDecryptor::OnSessionExpirationUpdate, weak_this),
       base::Bind(&ProxyDecryptor::OnCdmCreated, weak_this, key_system,
                  security_origin, cdm_context_ready_cb));
 }
 
 void ProxyDecryptor::OnCdmCreated(const std::string& key_system,
                                   const GURL& security_origin,
@@ skipping 297 matching lines @@
   bool is_persistent =
       session_type == PersistentSession || session_type == LoadSession;
   active_sessions_.insert(std::make_pair(session_id, is_persistent));
 
   // For LoadSession(), generate the KeyAdded event.
   if (session_type == LoadSession)
     GenerateKeyAdded(session_id);
 }
 
 }  // namespace media