PPAPI: Run clang_format.py on content/renderer/pepper

content/renderer/pepper/content_decryptor_delegate.cc

 // Copyright (c) 2012 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/pepper/content_decryptor_delegate.h"
 
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/numerics/safe_conversions.h"
@@ skipping 25 matching lines @@
 
 namespace content {
 
 namespace {
 
 // Fills |resource| with a PPB_Buffer_Impl and copies |data| into the buffer
 // resource. The |*resource|, if valid, will be in the ResourceTracker with a
 // reference-count of 0. If |data| is NULL, sets |*resource| to NULL. Returns
 // true upon success and false if any error happened.
 bool MakeBufferResource(PP_Instance instance,
-                        const uint8* data, uint32_t size,
+                        const uint8* data,
+                        uint32_t size,
                         scoped_refptr<PPB_Buffer_Impl>* resource) {
   TRACE_EVENT0("media", "ContentDecryptorDelegate - MakeBufferResource");
   DCHECK(resource);
 
   if (!data || !size) {
     DCHECK(!data && !size);
     resource = NULL;
     return true;
   }
 
@@ skipping 304 matching lines @@
     case Decryptor::kVideo:
       video_decrypt_cb_.Set(request_id, decrypt_cb);
       break;
     default:
       NOTREACHED();
       return false;
   }
 
   SetBufferToFreeInTrackingInfo(&block_info.tracking_info);
 
-  plugin_decryption_interface_->Decrypt(pp_instance_,
-                                        pp_resource,
-                                        &block_info);
+  plugin_decryption_interface_->Decrypt(pp_instance_, pp_resource, &block_info);
   return true;
 }
 
 bool ContentDecryptorDelegate::CancelDecrypt(
     Decryptor::StreamType stream_type) {
   DVLOG(3) << "CancelDecrypt() - stream_type: " << stream_type;
 
   Decryptor::DecryptCB decrypt_cb;
   switch (stream_type) {
     case Decryptor::kAudio:
@@ skipping 40 matching lines @@
   scoped_refptr<PPB_Buffer_Impl> extra_data_resource;
   if (!MakeBufferResource(pp_instance_,
                           decoder_config.extra_data(),
                           decoder_config.extra_data_size(),
                           &extra_data_resource)) {
     return false;
   }
   ScopedPPResource pp_resource(extra_data_resource.get());
 
   audio_decoder_init_cb_.Set(pp_decoder_config.request_id, init_cb);
-  plugin_decryption_interface_->InitializeAudioDecoder(pp_instance_,
-                                                       &pp_decoder_config,
-                                                       pp_resource);
+  plugin_decryption_interface_->InitializeAudioDecoder(
+      pp_instance_, &pp_decoder_config, pp_resource);
   return true;
 }
 
 bool ContentDecryptorDelegate::InitializeVideoDecoder(
     const media::VideoDecoderConfig& decoder_config,
     const Decryptor::DecoderInitCB& init_cb) {
   PP_VideoDecoderConfig pp_decoder_config;
   pp_decoder_config.codec =
       MediaVideoCodecToPpVideoCodec(decoder_config.codec());
   pp_decoder_config.profile =
       MediaVideoCodecProfileToPpVideoCodecProfile(decoder_config.profile());
   pp_decoder_config.format =
       MediaVideoFormatToPpDecryptedFrameFormat(decoder_config.format());
   pp_decoder_config.width = decoder_config.coded_size().width();
   pp_decoder_config.height = decoder_config.coded_size().height();
   pp_decoder_config.request_id = next_decryption_request_id_++;
 
   scoped_refptr<PPB_Buffer_Impl> extra_data_resource;
   if (!MakeBufferResource(pp_instance_,
                           decoder_config.extra_data(),
                           decoder_config.extra_data_size(),
                           &extra_data_resource)) {
     return false;
   }
   ScopedPPResource pp_resource(extra_data_resource.get());
 
   video_decoder_init_cb_.Set(pp_decoder_config.request_id, init_cb);
   natural_size_ = decoder_config.natural_size();
 
-  plugin_decryption_interface_->InitializeVideoDecoder(pp_instance_,
-                                                       &pp_decoder_config,
-                                                       pp_resource);
+  plugin_decryption_interface_->InitializeVideoDecoder(
+      pp_instance_, &pp_decoder_config, pp_resource);
   return true;
 }
 
 bool ContentDecryptorDelegate::DeinitializeDecoder(
     Decryptor::StreamType stream_type) {
   CancelDecode(stream_type);
 
   if (stream_type == Decryptor::kVideo)
     natural_size_ = gfx::Size();
 
@@ skipping 14 matching lines @@
 }
 
 bool ContentDecryptorDelegate::DecryptAndDecodeAudio(
     const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
     const Decryptor::AudioDecodeCB& audio_decode_cb) {
   // |audio_input_resource_| is not being used by the plugin now
   // because there is only one pending audio decode request at any time.
   // This is enforced by the media pipeline.
   scoped_refptr<PPB_Buffer_Impl> encrypted_resource;
   if (!MakeMediaBufferResource(
-           Decryptor::kAudio, encrypted_buffer, &encrypted_resource)) {
+          Decryptor::kAudio, encrypted_buffer, &encrypted_resource)) {
     return false;
   }
 
   // The resource should not be NULL for non-EOS buffer.
   if (!encrypted_buffer->end_of_stream() && !encrypted_resource.get())
     return false;
 
   const uint32_t request_id = next_decryption_request_id_++;
   DVLOG(2) << "DecryptAndDecodeAudio() - request_id " << request_id;
 
   PP_EncryptedBlockInfo block_info = {};
   if (!MakeEncryptedBlockInfo(encrypted_buffer, request_id, &block_info)) {
     return false;
   }
 
   SetBufferToFreeInTrackingInfo(&block_info.tracking_info);
 
   // There is only one pending audio decode request at any time. This is
   // enforced by the media pipeline. If this DCHECK is violated, our buffer
   // reuse policy is not valid, and we may have race problems for the shared
   // buffer.
   audio_decode_cb_.Set(request_id, audio_decode_cb);
 
   ScopedPPResource pp_resource(encrypted_resource.get());
-  plugin_decryption_interface_->DecryptAndDecode(pp_instance_,
-                                                 PP_DECRYPTORSTREAMTYPE_AUDIO,
-                                                 pp_resource,
-                                                 &block_info);
+  plugin_decryption_interface_->DecryptAndDecode(
+      pp_instance_, PP_DECRYPTORSTREAMTYPE_AUDIO, pp_resource, &block_info);
   return true;
 }
 
 bool ContentDecryptorDelegate::DecryptAndDecodeVideo(
     const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
     const Decryptor::VideoDecodeCB& video_decode_cb) {
   // |video_input_resource_| is not being used by the plugin now
   // because there is only one pending video decode request at any time.
   // This is enforced by the media pipeline.
   scoped_refptr<PPB_Buffer_Impl> encrypted_resource;
   if (!MakeMediaBufferResource(
-           Decryptor::kVideo, encrypted_buffer, &encrypted_resource)) {
+          Decryptor::kVideo, encrypted_buffer, &encrypted_resource)) {
     return false;
   }
 
   // The resource should not be 0 for non-EOS buffer.
   if (!encrypted_buffer->end_of_stream() && !encrypted_resource.get())
     return false;
 
   const uint32_t request_id = next_decryption_request_id_++;
   DVLOG(2) << "DecryptAndDecodeVideo() - request_id " << request_id;
   TRACE_EVENT_ASYNC_BEGIN0(
       "media", "ContentDecryptorDelegate::DecryptAndDecodeVideo", request_id);
 
   PP_EncryptedBlockInfo block_info = {};
   if (!MakeEncryptedBlockInfo(encrypted_buffer, request_id, &block_info)) {
     return false;
   }
 
   SetBufferToFreeInTrackingInfo(&block_info.tracking_info);
 
   // Only one pending video decode request at any time. This is enforced by the
   // media pipeline. If this DCHECK is violated, our buffer
   // reuse policy is not valid, and we may have race problems for the shared
   // buffer.
   video_decode_cb_.Set(request_id, video_decode_cb);
 
   // TODO(tomfinegan): Need to get stream type from media stack.
   ScopedPPResource pp_resource(encrypted_resource.get());
-  plugin_decryption_interface_->DecryptAndDecode(pp_instance_,
-                                                 PP_DECRYPTORSTREAMTYPE_VIDEO,
-                                                 pp_resource,
-                                                 &block_info);
+  plugin_decryption_interface_->DecryptAndDecode(
+      pp_instance_, PP_DECRYPTORSTREAMTYPE_VIDEO, pp_resource, &block_info);
   return true;
 }
 
 void ContentDecryptorDelegate::OnSessionCreated(uint32 session_id,
                                                 PP_Var web_session_id_var) {
   if (session_created_cb_.is_null())
     return;
 
   StringVar* session_id_string = StringVar::FromPPVar(web_session_id_var);
 
@@ skipping 48 matching lines @@
                                               uint32_t system_code) {
   if (session_error_cb_.is_null())
     return;
 
   session_error_cb_.Run(session_id,
                         static_cast<media::MediaKeys::KeyError>(media_error),
                         system_code);
 }
 
 void ContentDecryptorDelegate::DecoderInitializeDone(
-     PP_DecryptorStreamType decoder_type,
-     uint32_t request_id,
-     PP_Bool success) {
+    PP_DecryptorStreamType decoder_type,
+    uint32_t request_id,
+    PP_Bool success) {
   if (decoder_type == PP_DECRYPTORSTREAMTYPE_AUDIO) {
     // If the request ID is not valid or does not match what's saved, do
     // nothing.
     if (request_id == 0 || !audio_decoder_init_cb_.Matches(request_id))
       return;
 
     audio_decoder_init_cb_.ResetAndReturn().Run(PP_ToBool(success));
   } else {
     if (request_id == 0 || !video_decoder_init_cb_.Matches(request_id))
       return;
@@ skipping 58 matching lines @@
   BufferAutoMapper mapper(enter.object());
   if (!mapper.data() || !mapper.size() ||
       mapper.size() < block_info->data_size) {
     decrypt_cb.Run(Decryptor::kError, NULL);
     return;
   }
 
   // TODO(tomfinegan): Find a way to take ownership of the shared memory
   // managed by the PPB_Buffer_Dev, and avoid the extra copy.
   scoped_refptr<media::DecoderBuffer> decrypted_buffer(
-      media::DecoderBuffer::CopyFrom(
-          static_cast<uint8*>(mapper.data()), block_info->data_size));
-  decrypted_buffer->set_timestamp(base::TimeDelta::FromMicroseconds(
-      block_info->tracking_info.timestamp));
+      media::DecoderBuffer::CopyFrom(static_cast<uint8*>(mapper.data()),
+                                     block_info->data_size));
+  decrypted_buffer->set_timestamp(
+      base::TimeDelta::FromMicroseconds(block_info->tracking_info.timestamp));
   decrypt_cb.Run(Decryptor::kSuccess, decrypted_buffer);
 }
 
 // Use a non-class-member function here so that if for some reason
 // ContentDecryptorDelegate is destroyed before VideoFrame calls this callback,
 // we can still get the shared memory unmapped.
 static void BufferNoLongerNeeded(
     const scoped_refptr<PPB_Buffer_Impl>& ppb_buffer,
     base::Closure buffer_no_longer_needed_cb) {
   ppb_buffer->Unmap();
@@ skipping 184 matching lines @@
     const uint32_t kMinimumMediaBufferSize = 1024;
     uint32_t media_resource_size =
         media_resource.get() ? media_resource->size() : kMinimumMediaBufferSize;
     while (media_resource_size < data_size)
       media_resource_size *= 2;
 
     DVLOG(2) << "Size of media buffer for "
              << ((stream_type == Decryptor::kAudio) ? "audio" : "video")
              << " stream bumped to " << media_resource_size
              << " bytes to fit input.";
-    media_resource = PPB_Buffer_Impl::CreateResource(pp_instance_,
-                                                     media_resource_size);
+    media_resource =
+        PPB_Buffer_Impl::CreateResource(pp_instance_, media_resource_size);
     if (!media_resource.get())
       return false;
   }
 
   BufferAutoMapper mapper(media_resource.get());
   if (!mapper.data() || mapper.size() < data_size) {
     media_resource = NULL;
     return false;
   }
   memcpy(mapper.data(), encrypted_buffer->data(), data_size);
@@ skipping 39 matching lines @@
   const uint8* cur = static_cast<uint8*>(mapper.data());
   size_t bytes_left = data_size;
 
   const int audio_bytes_per_frame =
       media::SampleFormatToBytesPerChannel(sample_format) *
       audio_channel_count_;
   if (audio_bytes_per_frame <= 0)
     return false;
 
   // Allocate space for the channel pointers given to AudioBuffer.
-  std::vector<const uint8*> channel_ptrs(
-      audio_channel_count_, static_cast<const uint8*>(NULL));
+  std::vector<const uint8*> channel_ptrs(audio_channel_count_,
+                                         static_cast<const uint8*>(NULL));
   do {
     int64 timestamp = 0;
     int64 frame_size = -1;
     const size_t kHeaderSize = sizeof(timestamp) + sizeof(frame_size);
 
     if (bytes_left < kHeaderSize)
       return false;
 
     memcpy(&timestamp, cur, sizeof(timestamp));
     cur += sizeof(timestamp);
@@ skipping 55 matching lines @@
     const media::Decryptor::AudioBuffers empty_frames;
     audio_decode_cb_.ResetAndReturn().Run(media::Decryptor::kError,
                                           empty_frames);
   }
 
   if (!video_decode_cb_.is_null())
     video_decode_cb_.ResetAndReturn().Run(media::Decryptor::kError, NULL);
 }
 
 }  // namespace content