media/mojo/services/mojo_media_drm_storage.cc

   1 // Copyright 2017 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/mojo/services/mojo_media_drm_storage.h"
   6
   7 #include <string>
   8 #include <utility>
   9
  10 #include "base/functional/bind.h"
  11 #include "base/functional/callback_helpers.h"
  12 #include "base/unguessable_token.h"
  13 #include "media/mojo/mojom/media_drm_storage.mojom.h"
  14 #include "mojo/public/cpp/bindings/callback_helpers.h"
  15 #include "third_party/abseil-cpp/absl/types/optional.h"
  16
  17 namespace media {
  18
  19 // TODO(xhwang): When connection error happens, callbacks might be dropped and
  20 // never run. Handle connection error to make sure callbacks will always run.
  21
  22 MojoMediaDrmStorage::MojoMediaDrmStorage(
  23     mojo::PendingRemote<mojom::MediaDrmStorage> media_drm_storage)
  24     : media_drm_storage_(std::move(media_drm_storage)) {
  25   DVLOG(1) << __func__;
  26 }
  27
  28 MojoMediaDrmStorage::~MojoMediaDrmStorage() {}
  29
  30 void MojoMediaDrmStorage::Initialize(InitCB init_cb) {
  31   DVLOG(1) << __func__;
  32   media_drm_storage_->Initialize(mojo::WrapCallbackWithDefaultInvokeIfNotRun(
  33       std::move(init_cb), false, absl::nullopt));
  34 }
  35
  36 void MojoMediaDrmStorage::OnProvisioned(ResultCB result_cb) {
  37   DVLOG(1) << __func__;
  38   media_drm_storage_->OnProvisioned(
  39       mojo::WrapCallbackWithDefaultInvokeIfNotRun(std::move(result_cb), false));
  40 }
  41
  42 void MojoMediaDrmStorage::SavePersistentSession(const std::string& session_id,
  43                                                 const SessionData& session_data,
  44                                                 ResultCB result_cb) {
  45   DVLOG(1) << __func__;
  46   media_drm_storage_->SavePersistentSession(
  47       session_id,
  48       mojom::SessionData::New(session_data.key_set_id, session_data.mime_type,
  49                               session_data.key_type),
  50       mojo::WrapCallbackWithDefaultInvokeIfNotRun(std::move(result_cb), false));
  51 }
  52
  53 void MojoMediaDrmStorage::LoadPersistentSession(
  54     const std::string& session_id,
  55     LoadPersistentSessionCB load_persistent_session_cb) {
  56   DVLOG(1) << __func__;
  57   media_drm_storage_->LoadPersistentSession(
  58       session_id,
  59       mojo::WrapCallbackWithDefaultInvokeIfNotRun(
  60           base::BindOnce(&MojoMediaDrmStorage::OnPersistentSessionLoaded,
  61                          weak_factory_.GetWeakPtr(),
  62                          std::move(load_persistent_session_cb)),
  63           nullptr));
  64 }
  65
  66 void MojoMediaDrmStorage::RemovePersistentSession(const std::string& session_id,
  67                                                   ResultCB result_cb) {
  68   DVLOG(1) << __func__;
  69   media_drm_storage_->RemovePersistentSession(
  70       session_id,
  71       mojo::WrapCallbackWithDefaultInvokeIfNotRun(std::move(result_cb), false));
  72 }
  73
  74 void MojoMediaDrmStorage::OnPersistentSessionLoaded(
  75     LoadPersistentSessionCB load_persistent_session_cb,
  76     mojom::SessionDataPtr session_data) {
  77   DVLOG(1) << __func__ << ": success = " << !!session_data;
  78
  79   std::move(load_persistent_session_cb)
  80       .Run(session_data
  81                ? std::make_unique<SessionData>(
  82                      std::move(session_data->key_set_id),
  83                      std::move(session_data->mime_type), session_data->key_type)
  84                : nullptr);
  85 }
  86
  87 }  // namespace media