Rename cdm_adapter to ppapi_cdm_adapter

media/cdm/ppapi/ppapi_cdm_adapter.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/ppapi/cdm_adapter.h"
+#include "media/cdm/ppapi/ppapi_cdm_adapter.h"
 
 #include "media/base/limits.h"
 #include "media/cdm/ppapi/cdm_file_io_impl.h"
 #include "media/cdm/ppapi/cdm_logging.h"
-#include "media/cdm/ppapi/supported_cdm_versions.h"
+#include "media/cdm/supported_cdm_versions.h"
 #include "ppapi/c/ppb_console.h"
 #include "ppapi/cpp/private/uma_private.h"
 
 #if defined(CHECK_DOCUMENT_URL)
 #include "ppapi/cpp/dev/url_util_dev.h"
 #include "ppapi/cpp/instance_handle.h"
 #endif  // defined(CHECK_DOCUMENT_URL)
 
 namespace {
 
 // Constants for UMA reporting of file size (in KB) via HistogramCustomCounts().
 // Note that the histogram is log-scaled (rather than linear).
 const uint32_t kSizeKBMin = 1;
 const uint32_t kSizeKBMax = 512 * 1024;  // 512MB
 const uint32_t kSizeKBBuckets = 100;
 
 #if !defined(NDEBUG)
-  #define DLOG_TO_CONSOLE(message) LogToConsole(message);
+#define DLOG_TO_CONSOLE(message) LogToConsole(message);
 #else
-  #define DLOG_TO_CONSOLE(message) (void)(message);
+#define DLOG_TO_CONSOLE(message) (void)(message);
 #endif
 
 bool IsMainThread() {
   return pp::Module::Get()->core()->IsMainThread();
 }
 
 // Posts a task to run |cb| on the main thread. The task is posted even if the
 // current thread is the main thread.
 void PostOnMain(pp::CompletionCallback cb) {
   pp::Module::Get()->core()->CallOnMainThread(0, cb, PP_OK);
 }
 
 // Ensures |cb| is called on the main thread, either because the current thread
 // is the main thread or by posting it to the main thread.
 void CallOnMain(pp::CompletionCallback cb) {
   // TODO(tomfinegan): This is only necessary because PPAPI doesn't allow calls
   // off the main thread yet. Remove this once the change lands.
   if (IsMainThread())
     cb.Run(PP_OK);
   else
     PostOnMain(cb);
 }
 
 // Configures a cdm::InputBuffer. |subsamples| must exist as long as
 // |input_buffer| is in use.
-void ConfigureInputBuffer(
-    const pp::Buffer_Dev& encrypted_buffer,
-    const PP_EncryptedBlockInfo& encrypted_block_info,
-    std::vector<cdm::SubsampleEntry>* subsamples,
-    cdm::InputBuffer* input_buffer) {
+void ConfigureInputBuffer(const pp::Buffer_Dev& encrypted_buffer,
+                          const PP_EncryptedBlockInfo& encrypted_block_info,
+                          std::vector<cdm::SubsampleEntry>* subsamples,
+                          cdm::InputBuffer* input_buffer) {
   PP_DCHECK(subsamples);
   PP_DCHECK(!encrypted_buffer.is_null());
 
   input_buffer->data = static_cast<uint8_t*>(encrypted_buffer.data());
   input_buffer->data_size = encrypted_block_info.data_size;
   PP_DCHECK(encrypted_buffer.size() >= input_buffer->data_size);
 
   PP_DCHECK(encrypted_block_info.key_id_size <=
             arraysize(encrypted_block_info.key_id));
   input_buffer->key_id_size = encrypted_block_info.key_id_size;
-  input_buffer->key_id = input_buffer->key_id_size > 0 ?
-      encrypted_block_info.key_id : NULL;
+  input_buffer->key_id =
+      input_buffer->key_id_size > 0 ? encrypted_block_info.key_id : NULL;
 
   PP_DCHECK(encrypted_block_info.iv_size <= arraysize(encrypted_block_info.iv));
   input_buffer->iv_size = encrypted_block_info.iv_size;
-  input_buffer->iv = encrypted_block_info.iv_size > 0 ?
-      encrypted_block_info.iv : NULL;
+  input_buffer->iv =
+      encrypted_block_info.iv_size > 0 ? encrypted_block_info.iv : NULL;
 
   input_buffer->num_subsamples = encrypted_block_info.num_subsamples;
   if (encrypted_block_info.num_subsamples > 0) {
     subsamples->reserve(encrypted_block_info.num_subsamples);
 
     for (uint32_t i = 0; i < encrypted_block_info.num_subsamples; ++i) {
-      subsamples->push_back(cdm::SubsampleEntry(
-          encrypted_block_info.subsamples[i].clear_bytes,
-          encrypted_block_info.subsamples[i].cipher_bytes));
+      subsamples->push_back(
+          cdm::SubsampleEntry(encrypted_block_info.subsamples[i].clear_bytes,
+                              encrypted_block_info.subsamples[i].cipher_bytes));
     }
 
     input_buffer->subsamples = &(*subsamples)[0];
   }
 
   input_buffer->timestamp = encrypted_block_info.tracking_info.timestamp;
 }
 
 PP_DecryptResult CdmStatusToPpDecryptResult(cdm::Status status) {
   switch (status) {
@@ skipping 302 matching lines @@
 
 void CdmAdapter::SetServerCertificate(uint32_t promise_id,
                                       pp::VarArrayBuffer server_certificate) {
   const uint8_t* server_certificate_ptr =
       static_cast<const uint8_t*>(server_certificate.Map());
   const uint32_t server_certificate_size = server_certificate.ByteLength();
 
   if (!server_certificate_ptr ||
       server_certificate_size < media::limits::kMinCertificateLength ||
       server_certificate_size > media::limits::kMaxCertificateLength) {
-    RejectPromise(
-        promise_id, cdm::kInvalidAccessError, 0, "Incorrect certificate.");
+    RejectPromise(promise_id, cdm::kInvalidAccessError, 0,
+                  "Incorrect certificate.");
     return;
   }
 
-  cdm_->SetServerCertificate(
-      promise_id, server_certificate_ptr, server_certificate_size);
+  cdm_->SetServerCertificate(promise_id, server_certificate_ptr,
+                             server_certificate_size);
 }
 
 void CdmAdapter::CreateSessionAndGenerateRequest(uint32_t promise_id,
                                                  PP_SessionType session_type,
                                                  PP_InitDataType init_data_type,
                                                  pp::VarArrayBuffer init_data) {
   cdm_->CreateSessionAndGenerateRequest(
       promise_id, PpSessionTypeToCdmSessionType(session_type),
       PpInitDataTypeToCdmInitDataType(init_data_type),
       static_cast<const uint8_t*>(init_data.Map()), init_data.ByteLength());
@@ skipping 47 matching lines @@
     cdm::InputBuffer input_buffer;
     std::vector<cdm::SubsampleEntry> subsamples;
     ConfigureInputBuffer(encrypted_buffer, encrypted_block_info, &subsamples,
                          &input_buffer);
     status = cdm_->Decrypt(input_buffer, decrypted_block.get());
     PP_DCHECK(status != cdm::kSuccess ||
               (decrypted_block->DecryptedBuffer() &&
                decrypted_block->DecryptedBuffer()->Size()));
   }
 
-  CallOnMain(callback_factory_.NewCallback(
-      &CdmAdapter::DeliverBlock,
-      status,
-      decrypted_block,
-      encrypted_block_info.tracking_info));
+  CallOnMain(callback_factory_.NewCallback(&CdmAdapter::DeliverBlock, status,
+                                           decrypted_block,
+                                           encrypted_block_info.tracking_info));
 }
 
 void CdmAdapter::InitializeAudioDecoder(
     const PP_AudioDecoderConfig& decoder_config,
     pp::Buffer_Dev extra_data_buffer) {
   PP_DCHECK(!deferred_initialize_audio_decoder_);
   PP_DCHECK(deferred_audio_decoder_config_id_ == 0);
   cdm::Status status = cdm::kSessionError;
   if (cdm_) {
     cdm::AudioDecoderConfig cdm_decoder_config;
     cdm_decoder_config.codec =
         PpAudioCodecToCdmAudioCodec(decoder_config.codec);
     cdm_decoder_config.channel_count = decoder_config.channel_count;
     cdm_decoder_config.bits_per_channel = decoder_config.bits_per_channel;
     cdm_decoder_config.samples_per_second = decoder_config.samples_per_second;
     cdm_decoder_config.extra_data =
         static_cast<uint8_t*>(extra_data_buffer.data());
     cdm_decoder_config.extra_data_size = extra_data_buffer.size();
     status = cdm_->InitializeAudioDecoder(cdm_decoder_config);
   }
 
   if (status == cdm::kDeferredInitialization) {
     deferred_initialize_audio_decoder_ = true;
     deferred_audio_decoder_config_id_ = decoder_config.request_id;
     return;
   }
 
   CallOnMain(callback_factory_.NewCallback(
-      &CdmAdapter::DecoderInitializeDone,
-      PP_DECRYPTORSTREAMTYPE_AUDIO,
-      decoder_config.request_id,
-      status == cdm::kSuccess));
+      &CdmAdapter::DecoderInitializeDone, PP_DECRYPTORSTREAMTYPE_AUDIO,
+      decoder_config.request_id, status == cdm::kSuccess));
 }
 
 void CdmAdapter::InitializeVideoDecoder(
     const PP_VideoDecoderConfig& decoder_config,
     pp::Buffer_Dev extra_data_buffer) {
   PP_DCHECK(!deferred_initialize_video_decoder_);
   PP_DCHECK(deferred_video_decoder_config_id_ == 0);
   cdm::Status status = cdm::kSessionError;
   if (cdm_) {
     cdm::VideoDecoderConfig cdm_decoder_config;
@@ skipping 11 matching lines @@
     status = cdm_->InitializeVideoDecoder(cdm_decoder_config);
   }
 
   if (status == cdm::kDeferredInitialization) {
     deferred_initialize_video_decoder_ = true;
     deferred_video_decoder_config_id_ = decoder_config.request_id;
     return;
   }
 
   CallOnMain(callback_factory_.NewCallback(
-      &CdmAdapter::DecoderInitializeDone,
-      PP_DECRYPTORSTREAMTYPE_VIDEO,
-      decoder_config.request_id,
-      status == cdm::kSuccess));
+      &CdmAdapter::DecoderInitializeDone, PP_DECRYPTORSTREAMTYPE_VIDEO,
+      decoder_config.request_id, status == cdm::kSuccess));
 }
 
 void CdmAdapter::DeinitializeDecoder(PP_DecryptorStreamType decoder_type,
                                      uint32_t request_id) {
   PP_DCHECK(cdm_);  // InitializeXxxxxDecoder should have succeeded.
   if (cdm_) {
     cdm_->DeinitializeDecoder(
         PpDecryptorStreamTypeToCdmStreamType(decoder_type));
   }
 
-  CallOnMain(callback_factory_.NewCallback(
-      &CdmAdapter::DecoderDeinitializeDone,
-      decoder_type,
-      request_id));
+  CallOnMain(callback_factory_.NewCallback(&CdmAdapter::DecoderDeinitializeDone,
+                                           decoder_type, request_id));
 }
 
 void CdmAdapter::ResetDecoder(PP_DecryptorStreamType decoder_type,
                               uint32_t request_id) {
   PP_DCHECK(cdm_);  // InitializeXxxxxDecoder should have succeeded.
   if (cdm_)
     cdm_->ResetDecoder(PpDecryptorStreamTypeToCdmStreamType(decoder_type));
 
   CallOnMain(callback_factory_.NewCallback(&CdmAdapter::DecoderResetDone,
-                                           decoder_type,
-                                           request_id));
+                                           decoder_type, request_id));
 }
 
 void CdmAdapter::DecryptAndDecode(
     PP_DecryptorStreamType decoder_type,
     pp::Buffer_Dev encrypted_buffer,
     const PP_EncryptedBlockInfo& encrypted_block_info) {
   PP_DCHECK(cdm_);  // InitializeXxxxxDecoder should have succeeded.
   // Release a buffer that the caller indicated it is finished with.
   allocator_.Release(encrypted_block_info.tracking_info.buffer_id);
 
   cdm::InputBuffer input_buffer;
   std::vector<cdm::SubsampleEntry> subsamples;
   if (cdm_ && !encrypted_buffer.is_null()) {
-    ConfigureInputBuffer(encrypted_buffer,
-                         encrypted_block_info,
-                         &subsamples,
+    ConfigureInputBuffer(encrypted_buffer, encrypted_block_info, &subsamples,
                          &input_buffer);
   }
 
   cdm::Status status = cdm::kDecodeError;
 
   switch (decoder_type) {
     case PP_DECRYPTORSTREAMTYPE_VIDEO: {
       LinkedVideoFrame video_frame(new VideoFrameImpl());
       if (cdm_)
         status = cdm_->DecryptAndDecodeFrame(input_buffer, video_frame.get());
       CallOnMain(callback_factory_.NewCallback(
-          &CdmAdapter::DeliverFrame,
-          status,
-          video_frame,
+          &CdmAdapter::DeliverFrame, status, video_frame,
           encrypted_block_info.tracking_info));
       return;
     }
 
     case PP_DECRYPTORSTREAMTYPE_AUDIO: {
       LinkedAudioFrames audio_frames(new AudioFramesImpl());
       if (cdm_) {
-        status = cdm_->DecryptAndDecodeSamples(input_buffer,
-                                               audio_frames.get());
+        status =
+            cdm_->DecryptAndDecodeSamples(input_buffer, audio_frames.get());
       }
       CallOnMain(callback_factory_.NewCallback(
-          &CdmAdapter::DeliverSamples,
-          status,
-          audio_frames,
+          &CdmAdapter::DeliverSamples, status, audio_frames,
           encrypted_block_info.tracking_info));
       return;
     }
 
     default:
       PP_NOTREACHED();
       return;
   }
 }
 
 cdm::Buffer* CdmAdapter::Allocate(uint32_t capacity) {
   return allocator_.Allocate(capacity);
 }
 
 void CdmAdapter::SetTimer(int64_t delay_ms, void* context) {
   // NOTE: doesn't really need to run on the main thread; could just as well run
   // on a helper thread if |cdm_| were thread-friendly and care was taken.  We
   // only use CallOnMainThread() here to get delayed-execution behavior.
   pp::Module::Get()->core()->CallOnMainThread(
       delay_ms,
-      callback_factory_.NewCallback(&CdmAdapter::TimerExpired, context),
-      PP_OK);
+      callback_factory_.NewCallback(&CdmAdapter::TimerExpired, context), PP_OK);
 }
 
 void CdmAdapter::TimerExpired(int32_t result, void* context) {
   PP_DCHECK(result == PP_OK);
   cdm_->TimerExpired(context);
 }
 
 cdm::Time CdmAdapter::GetCurrentWallTime() {
   return pp::Module::Get()->core()->GetTime();
 }
@@ skipping 14 matching lines @@
 void CdmAdapter::OnRejectPromise(uint32_t promise_id,
                                  cdm::Error error,
                                  uint32_t system_code,
                                  const char* error_message,
                                  uint32_t error_message_size) {
   // UMA to investigate http://crbug.com/410630
   // TODO(xhwang): Remove after bug is fixed.
   if (system_code == 0x27) {
     pp::UMAPrivate uma_interface(this);
     uma_interface.HistogramCustomCounts("Media.EME.CdmFileIO.FileSizeKBOnError",
-                                        last_read_file_size_kb_,
-                                        kSizeKBMin,
-                                        kSizeKBMax,
-                                        kSizeKBBuckets);
+                                        last_read_file_size_kb_, kSizeKBMin,
+                                        kSizeKBMax, kSizeKBBuckets);
   }
 
   RejectPromise(promise_id, error, system_code,
                 std::string(error_message, error_message_size));
 }
 
 void CdmAdapter::RejectPromise(uint32_t promise_id,
                                cdm::Error error,
                                uint32_t system_code,
                                const std::string& error_message) {
   PostOnMain(callback_factory_.NewCallback(
-      &CdmAdapter::SendPromiseRejectedInternal,
-      promise_id,
+      &CdmAdapter::SendPromiseRejectedInternal, promise_id,
       SessionError(error, system_code, error_message)));
 }
 
 void CdmAdapter::OnSessionMessage(const char* session_id,
                                   uint32_t session_id_size,
                                   cdm::MessageType message_type,
                                   const char* message,
                                   uint32_t message_size,
                                   const char* legacy_destination_url,
                                   uint32_t legacy_destination_url_size) {
@@ skipping 85 matching lines @@
   PP_DCHECK(result == PP_OK);
   pp::ContentDecryptor_Private::PromiseResolvedWithSession(promise_id,
                                                            session_id);
 }
 
 void CdmAdapter::SendPromiseRejectedInternal(int32_t result,
                                              uint32_t promise_id,
                                              const SessionError& error) {
   PP_DCHECK(result == PP_OK);
   pp::ContentDecryptor_Private::PromiseRejected(
-      promise_id,
-      CdmExceptionTypeToPpCdmExceptionType(error.error),
-      error.system_code,
-      error.error_description);
+      promise_id, CdmExceptionTypeToPpCdmExceptionType(error.error),
+      error.system_code, error.error_description);
 }
 
 void CdmAdapter::SendSessionMessageInternal(int32_t result,
                                             const SessionMessage& message) {
   PP_DCHECK(result == PP_OK);
 
   pp::VarArrayBuffer message_array_buffer(message.message.size());
   if (message.message.size() > 0) {
     memcpy(message_array_buffer.Map(), message.message.data(),
            message.message.size());
@@ skipping 67 matching lines @@
   }
 
   pp::ContentDecryptor_Private::DeliverBlock(buffer, decrypted_block_info);
 }
 
 void CdmAdapter::DecoderInitializeDone(int32_t result,
                                        PP_DecryptorStreamType decoder_type,
                                        uint32_t request_id,
                                        bool success) {
   PP_DCHECK(result == PP_OK);
-  pp::ContentDecryptor_Private::DecoderInitializeDone(decoder_type,
-                                                      request_id,
+  pp::ContentDecryptor_Private::DecoderInitializeDone(decoder_type, request_id,
                                                       success);
 }
 
 void CdmAdapter::DecoderDeinitializeDone(int32_t result,
                                          PP_DecryptorStreamType decoder_type,
                                          uint32_t request_id) {
   pp::ContentDecryptor_Private::DecoderDeinitializeDone(decoder_type,
                                                         request_id);
 }
 
 void CdmAdapter::DecoderResetDone(int32_t result,
                                   PP_DecryptorStreamType decoder_type,
                                   uint32_t request_id) {
   pp::ContentDecryptor_Private::DecoderResetDone(decoder_type, request_id);
 }
 
-void CdmAdapter::DeliverFrame(
-    int32_t result,
-    const cdm::Status& status,
-    const LinkedVideoFrame& video_frame,
-    const PP_DecryptTrackingInfo& tracking_info) {
+void CdmAdapter::DeliverFrame(int32_t result,
+                              const cdm::Status& status,
+                              const LinkedVideoFrame& video_frame,
+                              const PP_DecryptTrackingInfo& tracking_info) {
   PP_DCHECK(result == PP_OK);
   PP_DecryptedFrameInfo decrypted_frame_info = {};
   decrypted_frame_info.tracking_info.request_id = tracking_info.request_id;
   decrypted_frame_info.tracking_info.buffer_id = 0;
   decrypted_frame_info.result = CdmStatusToPpDecryptResult(status);
 
   pp::Buffer_Dev buffer;
 
   if (decrypted_frame_info.result == PP_DECRYPTRESULT_SUCCESS) {
     if (!IsValidVideoFrame(video_frame)) {
@@ skipping 59 matching lines @@
           CdmAudioFormatToPpDecryptedSampleFormat(audio_frames->Format());
 
       buffer = ppb_buffer->TakeBuffer();
     }
   }
 
   pp::ContentDecryptor_Private::DeliverSamples(buffer, decrypted_sample_info);
 }
 
 bool CdmAdapter::IsValidVideoFrame(const LinkedVideoFrame& video_frame) {
-  if (!video_frame.get() ||
-      !video_frame->FrameBuffer() ||
+  if (!video_frame.get() || !video_frame->FrameBuffer() ||
       (video_frame->Format() != cdm::kI420 &&
        video_frame->Format() != cdm::kYv12)) {
     CDM_DLOG() << "Invalid video frame!";
     return false;
   }
 
   PpbBuffer* ppb_buffer = static_cast<PpbBuffer*>(video_frame->FrameBuffer());
 
   for (uint32_t i = 0; i < cdm::VideoFrame::kMaxPlanes; ++i) {
-    int plane_height = (i == cdm::VideoFrame::kYPlane) ?
-        video_frame->Size().height : (video_frame->Size().height + 1) / 2;
+    int plane_height = (i == cdm::VideoFrame::kYPlane)
+                           ? video_frame->Size().height
+                           : (video_frame->Size().height + 1) / 2;
     cdm::VideoFrame::VideoPlane plane =
         static_cast<cdm::VideoFrame::VideoPlane>(i);
     if (ppb_buffer->Size() < video_frame->PlaneOffset(plane) +
-                             plane_height * video_frame->Stride(plane)) {
+                                 plane_height * video_frame->Stride(plane)) {
       return false;
     }
   }
 
   return true;
 }
 
 void CdmAdapter::OnFirstFileRead(int32_t file_size_bytes) {
   PP_DCHECK(IsMainThread());
   PP_DCHECK(file_size_bytes >= 0);
 
   last_read_file_size_kb_ = file_size_bytes / 1024;
 
   if (file_size_uma_reported_)
     return;
 
   pp::UMAPrivate uma_interface(this);
   uma_interface.HistogramCustomCounts(
-      "Media.EME.CdmFileIO.FileSizeKBOnFirstRead",
-      last_read_file_size_kb_,
-      kSizeKBMin,
-      kSizeKBMax,
-      kSizeKBBuckets);
+      "Media.EME.CdmFileIO.FileSizeKBOnFirstRead", last_read_file_size_kb_,
+      kSizeKBMin, kSizeKBMax, kSizeKBBuckets);
   file_size_uma_reported_ = true;
 }
 
 #if !defined(NDEBUG)
 void CdmAdapter::LogToConsole(const pp::Var& value) {
   PP_DCHECK(IsMainThread());
   const PPB_Console* console = reinterpret_cast<const PPB_Console*>(
       pp::Module::Get()->GetBrowserInterface(PPB_CONSOLE_INTERFACE));
   console->Log(pp_instance(), PP_LOGLEVEL_LOG, value.pp_var());
 }
@@ skipping 10 matching lines @@
     pp::VarArrayBuffer challenge_var(challenge_size);
     uint8_t* var_data = static_cast<uint8_t*>(challenge_var.Map());
     memcpy(var_data, challenge, challenge_size);
 
     std::string service_id_str(service_id, service_id_size);
 
     linked_ptr<PepperPlatformChallengeResponse> response(
         new PepperPlatformChallengeResponse());
 
     int32_t result = platform_verification_.ChallengePlatform(
-        pp::Var(service_id_str),
-        challenge_var,
-        &response->signed_data,
-        &response->signed_data_signature,
-        &response->platform_key_certificate,
+        pp::Var(service_id_str), challenge_var, &response->signed_data,
+        &response->signed_data_signature, &response->platform_key_certificate,
         callback_factory_.NewCallback(&CdmAdapter::SendPlatformChallengeDone,
                                       response));
     challenge_var.Unmap();
     if (result == PP_OK_COMPLETIONPENDING)
       return;
 
     // Fall through on error and issue an empty OnPlatformChallengeResponse().
     PP_DCHECK(result != PP_OK);
   }
 #endif
 
   cdm::PlatformChallengeResponse platform_challenge_response = {};
   cdm_->OnPlatformChallengeResponse(platform_challenge_response);
 }
 
 void CdmAdapter::EnableOutputProtection(uint32_t desired_protection_mask) {
 #if defined(OS_CHROMEOS)
   int32_t result = output_protection_.EnableProtection(
-      desired_protection_mask, callback_factory_.NewCallback(
-          &CdmAdapter::EnableProtectionDone));
+      desired_protection_mask,
+      callback_factory_.NewCallback(&CdmAdapter::EnableProtectionDone));
 
   // Errors are ignored since clients must call QueryOutputProtectionStatus() to
   // inspect the protection status on a regular basis.
 
   if (result != PP_OK && result != PP_OK_COMPLETIONPENDING)
     CDM_DLOG() << __FUNCTION__ << " failed!";
 #endif
 }
 
 void CdmAdapter::QueryOutputProtectionStatus() {
 #if defined(OS_CHROMEOS)
   PP_DCHECK(!query_output_protection_in_progress_);
 
   output_link_mask_ = output_protection_mask_ = 0;
   const int32_t result = output_protection_.QueryStatus(
-      &output_link_mask_,
-      &output_protection_mask_,
+      &output_link_mask_, &output_protection_mask_,
       callback_factory_.NewCallback(
           &CdmAdapter::QueryOutputProtectionStatusDone));
   if (result == PP_OK_COMPLETIONPENDING) {
     query_output_protection_in_progress_ = true;
     ReportOutputProtectionQuery();
     return;
   }
 
   // Fall through on error and issue an empty OnQueryOutputProtectionStatus().
   PP_DCHECK(result != PP_OK);
   CDM_DLOG() << __FUNCTION__ << " failed, result = " << result;
 #endif
   cdm_->OnQueryOutputProtectionStatus(cdm::kQueryFailed, 0, 0);
 }
 
 void CdmAdapter::OnDeferredInitializationDone(cdm::StreamType stream_type,
                                               cdm::Status decoder_status) {
   switch (stream_type) {
     case cdm::kStreamTypeAudio:
       PP_DCHECK(deferred_initialize_audio_decoder_);
-      CallOnMain(
-          callback_factory_.NewCallback(&CdmAdapter::DecoderInitializeDone,
-                                        PP_DECRYPTORSTREAMTYPE_AUDIO,
-                                        deferred_audio_decoder_config_id_,
-                                        decoder_status == cdm::kSuccess));
+      CallOnMain(callback_factory_.NewCallback(
+          &CdmAdapter::DecoderInitializeDone, PP_DECRYPTORSTREAMTYPE_AUDIO,
+          deferred_audio_decoder_config_id_, decoder_status == cdm::kSuccess));
       deferred_initialize_audio_decoder_ = false;
       deferred_audio_decoder_config_id_ = 0;
       break;
     case cdm::kStreamTypeVideo:
       PP_DCHECK(deferred_initialize_video_decoder_);
-      CallOnMain(
-          callback_factory_.NewCallback(&CdmAdapter::DecoderInitializeDone,
-                                        PP_DECRYPTORSTREAMTYPE_VIDEO,
-                                        deferred_video_decoder_config_id_,
-                                        decoder_status == cdm::kSuccess));
+      CallOnMain(callback_factory_.NewCallback(
+          &CdmAdapter::DecoderInitializeDone, PP_DECRYPTORSTREAMTYPE_VIDEO,
+          deferred_video_decoder_config_id_, decoder_status == cdm::kSuccess));
       deferred_initialize_video_decoder_ = false;
       deferred_video_decoder_config_id_ = 0;
       break;
   }
 }
 
 // The CDM owns the returned object and must call FileIO::Close() to release it.
 cdm::FileIO* CdmAdapter::CreateFileIO(cdm::FileIOClient* client) {
   if (!allow_persistent_state_) {
     CDM_DLOG()
         << "Cannot create FileIO because persistent state is not allowed.";
     return nullptr;
   }
 
   return new CdmFileIOImpl(
       client, pp_instance(),
       callback_factory_.NewCallback(&CdmAdapter::OnFirstFileRead));
 }
 
 #if defined(OS_CHROMEOS)
 void CdmAdapter::ReportOutputProtectionUMA(OutputProtectionStatus status) {
   pp::UMAPrivate uma_interface(this);
-  uma_interface.HistogramEnumeration(
-      "Media.EME.OutputProtection", status, OUTPUT_PROTECTION_MAX);
+  uma_interface.HistogramEnumeration("Media.EME.OutputProtection", status,
+                                     OUTPUT_PROTECTION_MAX);
 }
 
 void CdmAdapter::ReportOutputProtectionQuery() {
   if (uma_for_output_protection_query_reported_)
     return;
 
   ReportOutputProtectionUMA(OUTPUT_PROTECTION_QUERIED);
   uma_for_output_protection_query_reported_ = true;
 }
 
@@ skipping 11 matching lines @@
   }
 
   const uint32_t kProtectableLinks =
       cdm::kLinkTypeHDMI | cdm::kLinkTypeDVI | cdm::kLinkTypeDisplayPort;
   bool is_unprotectable_link_connected = external_links & ~kProtectableLinks;
   bool is_hdcp_enabled_on_all_protectable_links =
       output_protection_mask_ & cdm::kProtectionHDCP;
 
   if (!is_unprotectable_link_connected &&
       is_hdcp_enabled_on_all_protectable_links) {
-    ReportOutputProtectionUMA(
-        OUTPUT_PROTECTION_ALL_EXTERNAL_LINKS_PROTECTED);
+    ReportOutputProtectionUMA(OUTPUT_PROTECTION_ALL_EXTERNAL_LINKS_PROTECTED);
     uma_for_output_protection_positive_result_reported_ = true;
     return;
   }
 
   // Do not report a negative result because it could be a false negative.
   // Instead, we will calculate number of negatives using the total number of
   // queries and success results.
 }
 
 void CdmAdapter::SendPlatformChallengeDone(
@@ skipping 48 matching lines @@
   cdm_->OnQueryOutputProtectionStatus(query_result, output_link_mask_,
                                       output_protection_mask_);
 }
 #endif
 
 CdmAdapter::SessionError::SessionError(cdm::Error error,
                                        uint32_t system_code,
                                        const std::string& error_description)
     : error(error),
       system_code(system_code),
-      error_description(error_description) {
-}
+      error_description(error_description) {}
 
 CdmAdapter::SessionMessage::SessionMessage(
     const std::string& session_id,
     cdm::MessageType message_type,
     const char* message,
     uint32_t message_size,
     const std::string& legacy_destination_url)
     : session_id(session_id),
       message_type(message_type),
       message(message, message + message_size),
-      legacy_destination_url(legacy_destination_url) {
-}
+      legacy_destination_url(legacy_destination_url) {}
 
 void* GetCdmHost(int host_interface_version, void* user_data) {
   if (!host_interface_version || !user_data)
     return NULL;
 
   static_assert(
       cdm::ContentDecryptionModule::Host::kVersion == cdm::Host_8::kVersion,
       "update the code below");
 
   // Ensure IsSupportedCdmHostVersion matches implementation of this function.
@@ skipping 27 matching lines @@
 
 // This object is the global object representing this plugin library as long
 // as it is loaded.
 class CdmAdapterModule : public pp::Module {
  public:
   CdmAdapterModule() : pp::Module() {
     // This function blocks the renderer thread (PluginInstance::Initialize()).
     // Move this call to other places if this may be a concern in the future.
     INITIALIZE_CDM_MODULE();
   }
-  virtual ~CdmAdapterModule() {
-    DeinitializeCdmModule();
-  }
+  virtual ~CdmAdapterModule() { DeinitializeCdmModule(); }
 
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
     return new CdmAdapter(instance, this);
   }
 
  private:
   CdmFileIOImpl::ResourceTracker cdm_file_io_impl_resource_tracker;
 };
 
 }  // namespace media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new media::CdmAdapterModule();
 }
 
 }  // namespace pp