Rename EME WD call parameters

content/renderer/media/webcontentdecryptionmodule_impl.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 "content/renderer/media/webcontentdecryptionmodule_impl.h"
 
 #include <map>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string_util.h"
 #include "content/renderer/media/crypto/content_decryption_module_factory.h"
 #include "content/renderer/media/webcontentdecryptionmodulesession_impl.h"
 #include "media/base/media_keys.h"
 #include "url/gurl.h"
 
 namespace content {
 
 // Forwards the reference ID-based callbacks of the MediaKeys interface to the

[ddorwin, 2013/12/05 00:44:52]

update

[jrummell, 2013/12/06 23:42:35]

Done.

 // appropriate session object.
 class ReferenceIdAdapter {

[ddorwin, 2013/12/05 00:44:52]

Rename. TODO?

[jrummell, 2013/12/06 23:42:35]

Implemented.

  public:
   ReferenceIdAdapter();
   ~ReferenceIdAdapter();
 
   // On success, creates a MediaKeys, returns it in |media_keys|, returns true.
   bool Initialize(const std::string& key_system,
                   scoped_ptr<media::MediaKeys>* media_keys);
 
   // Adds a session to the internal map. Does not take ownership of the session.
-  void AddSession(uint32 reference_id,
+  void AddSession(uint32 session_id,
                   WebContentDecryptionModuleSessionImpl* session);
 
   // Removes a session from the internal map.
-  void RemoveSession(uint32 reference_id);
+  void RemoveSession(uint32 session_id);
 
  private:
   typedef std::map<uint32, WebContentDecryptionModuleSessionImpl*> SessionMap;
 
   // Callbacks for firing session events.
-  void OnSessionCreated(uint32 reference_id, const std::string& session_id);
-  void OnSessionMessage(uint32 reference_id,
+  void OnSessionCreated(uint32 session_id, const std::string& web_session_id);
+  void OnSessionMessage(uint32 session_id,
                         const std::vector<uint8>& message,
                         const std::string& destination_url);
-  void OnSessionReady(uint32 reference_id);
-  void OnSessionClosed(uint32 reference_id);
-  void OnSessionError(uint32 reference_id,
+  void OnSessionReady(uint32 session_id);
+  void OnSessionClosed(uint32 session_id);
+  void OnSessionError(uint32 session_id,
                       media::MediaKeys::KeyError error_code,
                       int system_code);
 
   // Helper function of the callbacks.
-  WebContentDecryptionModuleSessionImpl* GetSession(uint32 reference_id);
+  WebContentDecryptionModuleSessionImpl* GetSession(uint32 session_id);
 
   base::WeakPtrFactory<ReferenceIdAdapter> weak_ptr_factory_;
 
   SessionMap sessions_;
 
   DISALLOW_COPY_AND_ASSIGN(ReferenceIdAdapter);
 };
 
 ReferenceIdAdapter::ReferenceIdAdapter()
     : weak_ptr_factory_(this) {
@@ skipping 30 matching lines @@
           base::Bind(&ReferenceIdAdapter::OnSessionClosed, weak_this),
           base::Bind(&ReferenceIdAdapter::OnSessionError, weak_this));
   if (!created_media_keys)
     return false;
 
   *media_keys = created_media_keys.Pass();
   return true;
 }
 
 void ReferenceIdAdapter::AddSession(
-    uint32 reference_id,
+    uint32 session_id,
     WebContentDecryptionModuleSessionImpl* session) {
-  DCHECK(sessions_.find(reference_id) == sessions_.end());
-  sessions_[reference_id] = session;
+  DCHECK(sessions_.find(session_id) == sessions_.end());
+  sessions_[session_id] = session;
 }
 
-void ReferenceIdAdapter::RemoveSession(uint32 reference_id) {
-  DCHECK(sessions_.find(reference_id) != sessions_.end());
-  sessions_.erase(reference_id);
+void ReferenceIdAdapter::RemoveSession(uint32 session_id) {
+  DCHECK(sessions_.find(session_id) != sessions_.end());
+  sessions_.erase(session_id);
 }
 
-void ReferenceIdAdapter::OnSessionCreated(uint32 reference_id,
-                                          const std::string& session_id) {
-  GetSession(reference_id)->OnSessionCreated(session_id);
+void ReferenceIdAdapter::OnSessionCreated(uint32 session_id,
+                                          const std::string& web_session_id) {
+  GetSession(session_id)->OnSessionCreated(web_session_id);
 }
 
-void ReferenceIdAdapter::OnSessionMessage(uint32 reference_id,
+void ReferenceIdAdapter::OnSessionMessage(uint32 session_id,
                                           const std::vector<uint8>& message,
                                           const std::string& destination_url) {
-  GetSession(reference_id)->OnSessionMessage(message, destination_url);
+  GetSession(session_id)->OnSessionMessage(message, destination_url);
 }
 
-void ReferenceIdAdapter::OnSessionReady(uint32 reference_id) {
-  GetSession(reference_id)->OnSessionReady();
+void ReferenceIdAdapter::OnSessionReady(uint32 session_id) {
+  GetSession(session_id)->OnSessionReady();
 }
 
-void ReferenceIdAdapter::OnSessionClosed(uint32 reference_id) {
-  GetSession(reference_id)->OnSessionClosed();
+void ReferenceIdAdapter::OnSessionClosed(uint32 session_id) {
+  GetSession(session_id)->OnSessionClosed();
 }
 
-void ReferenceIdAdapter::OnSessionError(uint32 reference_id,
+void ReferenceIdAdapter::OnSessionError(uint32 session_id,
                                         media::MediaKeys::KeyError error_code,
                                         int system_code) {
-  GetSession(reference_id)->OnSessionError(error_code, system_code);
+  GetSession(session_id)->OnSessionError(error_code, system_code);
 }
 
 WebContentDecryptionModuleSessionImpl* ReferenceIdAdapter::GetSession(
-    uint32 reference_id) {
-  DCHECK(sessions_.find(reference_id) != sessions_.end());
-  return sessions_[reference_id];
+    uint32 session_id) {
+  DCHECK(sessions_.find(session_id) != sessions_.end());
+  return sessions_[session_id];
 }
 
 //------------------------------------------------------------------------------
 
 WebContentDecryptionModuleImpl*
 WebContentDecryptionModuleImpl::Create(const string16& key_system) {
   // TODO(ddorwin): Guard against this in supported types check and remove this.
   // Chromium only supports ASCII key systems.
   if (!IsStringASCII(key_system)) {
     NOTREACHED();
@@ skipping 25 matching lines @@
 WebContentDecryptionModuleImpl::createSession(
     blink::WebContentDecryptionModuleSession::Client* client) {
   DCHECK(media_keys_);
   WebContentDecryptionModuleSessionImpl* session =
       new WebContentDecryptionModuleSessionImpl(
           media_keys_.get(),
           client,
           base::Bind(&WebContentDecryptionModuleImpl::OnSessionClosed,
                      base::Unretained(this)));
 
-  adapter_->AddSession(session->reference_id(), session);
+  adapter_->AddSession(session->session_id(), session);
   return session;
 }
 
-void WebContentDecryptionModuleImpl::OnSessionClosed(uint32 reference_id) {
-  adapter_->RemoveSession(reference_id);
+void WebContentDecryptionModuleImpl::OnSessionClosed(uint32 session_id) {
+  adapter_->RemoveSession(session_id);
 }
 
 }  // namespace content