// 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 session ID-based callbacks of the MediaKeys interface to the
// appropriate session object.
class SessionIdAdapter {
 public:
  SessionIdAdapter();
  ~SessionIdAdapter();

  // 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);

  // Generates a unique internal session id.
  uint32 GenerateSessionId();

  // Adds a session to the internal map. Does not take ownership of the session.
  void AddSession(uint32 session_id,
                  WebContentDecryptionModuleSessionImpl* session);

  // Removes a session from the internal map.
  void RemoveSession(uint32 session_id);

 private:
  typedef std::map<uint32, WebContentDecryptionModuleSessionImpl*> SessionMap;

  // Callbacks for firing session events.
  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 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 session_id);

  base::WeakPtrFactory<SessionIdAdapter> weak_ptr_factory_;

  SessionMap sessions_;

  // Session ID should be unique per renderer process for debugging purposes.
  static uint32 next_session_id_;

  DISALLOW_COPY_AND_ASSIGN(SessionIdAdapter);
};

const uint32 kStartingSessionId = 1;
uint32 SessionIdAdapter::next_session_id_ = kStartingSessionId;
COMPILE_ASSERT(kStartingSessionId > media::MediaKeys::kInvalidSessionId,
               invalid_starting_value);

SessionIdAdapter::SessionIdAdapter()
    : weak_ptr_factory_(this) {
}

SessionIdAdapter::~SessionIdAdapter() {
}

bool SessionIdAdapter::Initialize(const std::string& key_system,
                                  scoped_ptr<media::MediaKeys>* media_keys) {
  DCHECK(media_keys);
  DCHECK(!*media_keys);

  base::WeakPtr<SessionIdAdapter> weak_this = weak_ptr_factory_.GetWeakPtr();
  scoped_ptr<media::MediaKeys> created_media_keys =
      ContentDecryptionModuleFactory::Create(
          // TODO(ddorwin): Address lower in the stack: http://crbug.com/252065
          "webkit-" + key_system,
#if defined(ENABLE_PEPPER_CDMS)
          // TODO(ddorwin): Support Pepper-based CDMs: http://crbug.com/250049
          NULL,
          NULL,
          base::Closure(),
#elif defined(OS_ANDROID)
          // TODO(xhwang): Support Android.
          NULL,
          0,
          // TODO(ddorwin): Get the URL for the frame containing the MediaKeys.
          GURL(),
#endif  // defined(ENABLE_PEPPER_CDMS)
          base::Bind(&SessionIdAdapter::OnSessionCreated, weak_this),
          base::Bind(&SessionIdAdapter::OnSessionMessage, weak_this),
          base::Bind(&SessionIdAdapter::OnSessionReady, weak_this),
          base::Bind(&SessionIdAdapter::OnSessionClosed, weak_this),
          base::Bind(&SessionIdAdapter::OnSessionError, weak_this));
  if (!created_media_keys)
    return false;

  *media_keys = created_media_keys.Pass();
  return true;
}

uint32 SessionIdAdapter::GenerateSessionId() {
  return next_session_id_++;
}

void SessionIdAdapter::AddSession(
    uint32 session_id,
    WebContentDecryptionModuleSessionImpl* session) {
  DCHECK(sessions_.find(session_id) == sessions_.end());
  sessions_[session_id] = session;
}

void SessionIdAdapter::RemoveSession(uint32 session_id) {
  DCHECK(sessions_.find(session_id) != sessions_.end());
  sessions_.erase(session_id);
}

void SessionIdAdapter::OnSessionCreated(uint32 session_id,
                                        const std::string& web_session_id) {
  GetSession(session_id)->OnSessionCreated(web_session_id);
}

void SessionIdAdapter::OnSessionMessage(uint32 session_id,
                                        const std::vector<uint8>& message,
                                        const std::string& destination_url) {
  GetSession(session_id)->OnSessionMessage(message, destination_url);
}

void SessionIdAdapter::OnSessionReady(uint32 session_id) {
  GetSession(session_id)->OnSessionReady();
}

void SessionIdAdapter::OnSessionClosed(uint32 session_id) {
  GetSession(session_id)->OnSessionClosed();
}

void SessionIdAdapter::OnSessionError(uint32 session_id,
                                      media::MediaKeys::KeyError error_code,
                                      int system_code) {
  GetSession(session_id)->OnSessionError(error_code, system_code);
}

WebContentDecryptionModuleSessionImpl* SessionIdAdapter::GetSession(
    uint32 session_id) {
  DCHECK(sessions_.find(session_id) != sessions_.end());
  return sessions_[session_id];
}

//------------------------------------------------------------------------------

WebContentDecryptionModuleImpl*
WebContentDecryptionModuleImpl::Create(const base::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();
    return NULL;
  }

  // SessionIdAdapter creates the MediaKeys so it can provide its callbacks to
  // during creation of the MediaKeys.
  scoped_ptr<media::MediaKeys> media_keys;
  scoped_ptr<SessionIdAdapter> adapter(new SessionIdAdapter());
  if (!adapter->Initialize(UTF16ToASCII(key_system), &media_keys))
    return NULL;

  return new WebContentDecryptionModuleImpl(media_keys.Pass(), adapter.Pass());
}

WebContentDecryptionModuleImpl::WebContentDecryptionModuleImpl(
    scoped_ptr<media::MediaKeys> media_keys,
    scoped_ptr<SessionIdAdapter> adapter)
    : media_keys_(media_keys.Pass()),
      adapter_(adapter.Pass()) {
}

WebContentDecryptionModuleImpl::~WebContentDecryptionModuleImpl() {
}

// The caller owns the created session.
blink::WebContentDecryptionModuleSession*
WebContentDecryptionModuleImpl::createSession(
    blink::WebContentDecryptionModuleSession::Client* client) {
  DCHECK(media_keys_);
  uint32 session_id = adapter_->GenerateSessionId();
  WebContentDecryptionModuleSessionImpl* session =
      new WebContentDecryptionModuleSessionImpl(
          session_id,
          media_keys_.get(),
          client,
          base::Bind(&WebContentDecryptionModuleImpl::OnSessionClosed,
                     base::Unretained(this)));

  adapter_->AddSession(session_id, session);
  return session;
}

void WebContentDecryptionModuleImpl::OnSessionClosed(uint32 session_id) {
  adapter_->RemoveSession(session_id);
}

}  // namespace content