// 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/webcontentdecryptionmodulesession_impl.h"

#include "base/bind.h"
#include "base/callback_helpers.h"
#include "base/logging.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "content/renderer/media/cdm_session_adapter.h"
#include "media/base/cdm_promise.h"
#include "third_party/WebKit/public/platform/WebURL.h"

namespace content {

const char kCreateSessionUMAName[] = "CreateSession";

// For backwards compatibility with blink not using
// WebContentDecryptionModuleResult, reserve an index for |outstanding_results_|
// that will not be used when adding a WebContentDecryptionModuleResult.
// TODO(jrummell): Remove once blink always uses
// WebContentDecryptionModuleResult.
const uint32 kReservedIndex = 0;

static blink::WebContentDecryptionModuleException ConvertException(
    media::MediaKeys::Exception exception_code) {
  switch (exception_code) {
    case media::MediaKeys::NOT_SUPPORTED_ERROR:
      return blink::WebContentDecryptionModuleExceptionNotSupportedError;
    case media::MediaKeys::INVALID_STATE_ERROR:
      return blink::WebContentDecryptionModuleExceptionInvalidStateError;
    case media::MediaKeys::INVALID_ACCESS_ERROR:
      return blink::WebContentDecryptionModuleExceptionInvalidAccessError;
    case media::MediaKeys::QUOTA_EXCEEDED_ERROR:
      return blink::WebContentDecryptionModuleExceptionQuotaExceededError;
    case media::MediaKeys::UNKNOWN_ERROR:
      return blink::WebContentDecryptionModuleExceptionUnknownError;
    case media::MediaKeys::CLIENT_ERROR:
      return blink::WebContentDecryptionModuleExceptionClientError;
    case media::MediaKeys::OUTPUT_ERROR:
      return blink::WebContentDecryptionModuleExceptionOutputError;
    default:
      NOTREACHED();
      return blink::WebContentDecryptionModuleExceptionUnknownError;
  }
}

WebContentDecryptionModuleSessionImpl::WebContentDecryptionModuleSessionImpl(
    const scoped_refptr<CdmSessionAdapter>& adapter)
    : adapter_(adapter),
      is_closed_(false),
      next_available_result_index_(1),
      weak_ptr_factory_(this) {
}

WebContentDecryptionModuleSessionImpl::
    ~WebContentDecryptionModuleSessionImpl() {
  if (!web_session_id_.empty())
    adapter_->RemoveSession(web_session_id_);

  // Release any WebContentDecryptionModuleResult objects that are left. Their
  // index will have been passed down via a CdmPromise, but it uses a WeakPtr.
  DLOG_IF(WARNING, outstanding_results_.size() > 0)
      << "Clearing " << outstanding_results_.size() << " results";
  for (ResultMap::iterator it = outstanding_results_.begin();
       it != outstanding_results_.end();
       ++it) {
    it->second.completeWithError(
        blink::WebContentDecryptionModuleExceptionInvalidStateError,
        0,
        "Outstanding request being cancelled.");
  }
  outstanding_results_.clear();
}

void WebContentDecryptionModuleSessionImpl::setClientInterface(Client* client) {
  client_ = client;
}

blink::WebString WebContentDecryptionModuleSessionImpl::sessionId() const {
  return blink::WebString::fromUTF8(web_session_id_);
}

void WebContentDecryptionModuleSessionImpl::initializeNewSession(
    const blink::WebString& init_data_type,
    const uint8* init_data,
    size_t init_data_length) {
  DCHECK(base::IsStringASCII(init_data_type));

  std::string init_data_type_as_ascii = base::UTF16ToASCII(init_data_type);
  DLOG_IF(WARNING, init_data_type_as_ascii.find('/') != std::string::npos)
      << "init_data_type '" << init_data_type_as_ascii
      << "' may be a MIME type";

  // Attempt to translate content types.
  // TODO(sandersd): Remove once tests stop using content types.
  // http://crbug.com/385874
  std::string content_type = base::StringToLowerASCII(init_data_type_as_ascii);
  if (content_type == "audio/mp4" || content_type == "video/mp4") {
    init_data_type_as_ascii = "cenc";
  } else if (content_type == "audio/webm" || content_type == "video/webm") {
    init_data_type_as_ascii = "webm";
  }

  scoped_ptr<media::NewSessionCdmPromise> promise(
      new media::NewSessionCdmPromise(
          base::Bind(&WebContentDecryptionModuleSessionImpl::SessionCreated,
                     weak_ptr_factory_.GetWeakPtr(),
                     kReservedIndex),
          base::Bind(&WebContentDecryptionModuleSessionImpl::OnSessionError,
                     weak_ptr_factory_.GetWeakPtr()),
          adapter_->GetKeySystemUMAPrefix() + kCreateSessionUMAName));
  adapter_->InitializeNewSession(init_data_type_as_ascii,
                                 init_data,
                                 init_data_length,
                                 media::MediaKeys::TEMPORARY_SESSION,
                                 promise.Pass());
}

void WebContentDecryptionModuleSessionImpl::update(const uint8* response,
                                                   size_t response_length) {
  DCHECK(response);
  scoped_ptr<media::SimpleCdmPromise> promise(new media::SimpleCdmPromise(
      base::Bind(&WebContentDecryptionModuleSessionImpl::OnSessionReady,
                 weak_ptr_factory_.GetWeakPtr()),
      base::Bind(&WebContentDecryptionModuleSessionImpl::OnSessionError,
                 weak_ptr_factory_.GetWeakPtr())));
  adapter_->UpdateSession(
      web_session_id_, response, response_length, promise.Pass());
}

void WebContentDecryptionModuleSessionImpl::release() {
  scoped_ptr<media::SimpleCdmPromise> promise(new media::SimpleCdmPromise(
      base::Bind(&WebContentDecryptionModuleSessionImpl::OnSessionClosed,
                 weak_ptr_factory_.GetWeakPtr()),
      base::Bind(&WebContentDecryptionModuleSessionImpl::OnSessionError,
                 weak_ptr_factory_.GetWeakPtr())));
  adapter_->ReleaseSession(web_session_id_, promise.Pass());
}

void WebContentDecryptionModuleSessionImpl::initializeNewSession(
    const blink::WebString& init_data_type,
    const uint8* init_data,
    size_t init_data_length,
    const blink::WebString& session_type,
    blink::WebContentDecryptionModuleResult result) {
  uint32 result_index = AddResult(result);

  // TODO(ddorwin): Guard against this in supported types check and remove this.
  // Chromium only supports ASCII MIME types.
  if (!base::IsStringASCII(init_data_type)) {
    NOTREACHED();
    SessionError(result_index,
                 media::MediaKeys::NOT_SUPPORTED_ERROR,
                 0,
                 "The initialization data type " + init_data_type.utf8() +
                     " is not supported by the key system.");
    return;
  }

  std::string init_data_type_as_ascii = base::UTF16ToASCII(init_data_type);
  DLOG_IF(WARNING, init_data_type_as_ascii.find('/') != std::string::npos)
      << "init_data_type '" << init_data_type_as_ascii
      << "' may be a MIME type";

  scoped_ptr<media::NewSessionCdmPromise> promise(
      new media::NewSessionCdmPromise(
          base::Bind(&WebContentDecryptionModuleSessionImpl::SessionCreated,
                     weak_ptr_factory_.GetWeakPtr(),
                     result_index),
          base::Bind(&WebContentDecryptionModuleSessionImpl::SessionError,
                     weak_ptr_factory_.GetWeakPtr(),
                     result_index),
          adapter_->GetKeySystemUMAPrefix() + kCreateSessionUMAName));
  adapter_->InitializeNewSession(init_data_type_as_ascii,
                                 init_data,
                                 init_data_length,
                                 media::MediaKeys::TEMPORARY_SESSION,
                                 promise.Pass());
}

void WebContentDecryptionModuleSessionImpl::update(
    const uint8* response,
    size_t response_length,
    blink::WebContentDecryptionModuleResult result) {
  DCHECK(response);
  uint32 result_index = AddResult(result);
  scoped_ptr<media::SimpleCdmPromise> promise(new media::SimpleCdmPromise(
      base::Bind(
          &WebContentDecryptionModuleSessionImpl::SessionUpdatedOrReleased,
          weak_ptr_factory_.GetWeakPtr(),
          result_index),
      base::Bind(&WebContentDecryptionModuleSessionImpl::SessionError,
                 weak_ptr_factory_.GetWeakPtr(),
                 result_index)));
  adapter_->UpdateSession(
      web_session_id_, response, response_length, promise.Pass());
}

void WebContentDecryptionModuleSessionImpl::release(
    blink::WebContentDecryptionModuleResult result) {
  uint32 result_index = AddResult(result);
  scoped_ptr<media::SimpleCdmPromise> promise(new media::SimpleCdmPromise(
      base::Bind(
          &WebContentDecryptionModuleSessionImpl::SessionUpdatedOrReleased,
          weak_ptr_factory_.GetWeakPtr(),
          result_index),
      base::Bind(&WebContentDecryptionModuleSessionImpl::SessionError,
                 weak_ptr_factory_.GetWeakPtr(),
                 result_index)));
  adapter_->ReleaseSession(web_session_id_, promise.Pass());
}

void WebContentDecryptionModuleSessionImpl::OnSessionMessage(
    const std::vector<uint8>& message,
    const GURL& destination_url) {
  DCHECK(client_) << "Client not set before message event";
  client_->message(
      message.empty() ? NULL : &message[0], message.size(), destination_url);
}

void WebContentDecryptionModuleSessionImpl::OnSessionReady() {
  client_->ready();
}

void WebContentDecryptionModuleSessionImpl::OnSessionClosed() {
  if (!is_closed_) {
    is_closed_ = true;
    client_->close();
  }
}

void WebContentDecryptionModuleSessionImpl::OnSessionError(
    media::MediaKeys::Exception exception_code,
    uint32 system_code,
    const std::string& error_message) {
  // Convert |exception_code| back to MediaKeyErrorCode if possible.
  // TODO(jrummell): Update this conversion when promises flow
  // back into blink:: (as blink:: will have its own error definition).
  switch (exception_code) {
    case media::MediaKeys::CLIENT_ERROR:
      client_->error(Client::MediaKeyErrorCodeClient, system_code);
      break;
    default:
      // This will include all other CDM4 errors and any error generated
      // by CDM5 or later.
      client_->error(Client::MediaKeyErrorCodeUnknown, system_code);
      break;
  }
}

void WebContentDecryptionModuleSessionImpl::SessionCreated(
    uint32 result_index,
    const std::string& web_session_id) {
  blink::WebContentDecryptionModuleResult::SessionStatus status;

  // CDM will return NULL if the session to be loaded can't be found.
  if (web_session_id.empty()) {
    status = blink::WebContentDecryptionModuleResult::SessionNotFound;
  } else {
    DCHECK(web_session_id_.empty())
        << "Session ID may not be changed once set.";
    web_session_id_ = web_session_id;
    status =
        adapter_->RegisterSession(web_session_id_,
                                  weak_ptr_factory_.GetWeakPtr())
            ? blink::WebContentDecryptionModuleResult::NewSession
            : blink::WebContentDecryptionModuleResult::SessionAlreadyExists;
  }

  ResultMap::iterator it = outstanding_results_.find(result_index);
  if (it != outstanding_results_.end()) {
    blink::WebContentDecryptionModuleResult& result = it->second;
    result.completeWithSession(status);
    outstanding_results_.erase(result_index);
  }
}

void WebContentDecryptionModuleSessionImpl::SessionUpdatedOrReleased(
    uint32 result_index) {
  ResultMap::iterator it = outstanding_results_.find(result_index);
  DCHECK(it != outstanding_results_.end());
  blink::WebContentDecryptionModuleResult& result = it->second;
  result.complete();
  outstanding_results_.erase(it);
}

void WebContentDecryptionModuleSessionImpl::SessionError(
    uint32 result_index,
    media::MediaKeys::Exception exception_code,
    uint32 system_code,
    const std::string& error_message) {
  ResultMap::iterator it = outstanding_results_.find(result_index);
  DCHECK(it != outstanding_results_.end());
  blink::WebContentDecryptionModuleResult& result = it->second;
  result.completeWithError(ConvertException(exception_code),
                           system_code,
                           blink::WebString::fromUTF8(error_message));
  outstanding_results_.erase(it);
}

uint32 WebContentDecryptionModuleSessionImpl::AddResult(
    blink::WebContentDecryptionModuleResult result) {
  uint32 result_index = next_available_result_index_++;
  DCHECK(result_index != kReservedIndex);
  outstanding_results_.insert(std::make_pair(result_index, result));
  return result_index;
}

}  // namespace content