Fix silent truncations when extracting values from CheckedNumeric

content/renderer/pepper/pepper_audio_encoder_host.cc

 // Copyright 2015 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/pepper_audio_encoder_host.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 322 matching lines @@
 
   return false;
 }
 
 bool PepperAudioEncoderHost::AllocateBuffers(
     const ppapi::proxy::PPB_AudioEncodeParameters& parameters,
     int32_t samples_per_frame) {
   DCHECK(RenderThreadImpl::current());
 
   // Audio buffers size computation.
-  base::CheckedNumeric<size_t> audio_buffer_size = samples_per_frame;
+  base::CheckedNumeric<uint32_t> audio_buffer_size = samples_per_frame;
   audio_buffer_size *= parameters.channels;
   audio_buffer_size *= parameters.input_sample_size;
 
-  base::CheckedNumeric<size_t> total_audio_buffer_size = audio_buffer_size;
+  base::CheckedNumeric<uint32_t> total_audio_buffer_size = audio_buffer_size;
   total_audio_buffer_size += sizeof(ppapi::MediaStreamBuffer::Audio);
   base::CheckedNumeric<size_t> total_audio_memory_size =
       total_audio_buffer_size;
   total_audio_memory_size *= kDefaultNumberOfAudioBuffers;
 
   // Bitstream buffers size computation (individual bitstream buffers are
   // twice the size of the raw data, to handle the worst case where
   // compression doesn't work).
-  base::CheckedNumeric<size_t> bitstream_buffer_size = audio_buffer_size;
+  base::CheckedNumeric<uint32_t> bitstream_buffer_size = audio_buffer_size;
   bitstream_buffer_size *= 2;
   bitstream_buffer_size += sizeof(ppapi::MediaStreamBuffer::Bitstream);
   base::CheckedNumeric<size_t> total_bitstream_memory_size =
       bitstream_buffer_size;
   total_bitstream_memory_size *= kDefaultNumberOfAudioBuffers;
 
   if (!total_audio_memory_size.IsValid() ||
       !total_bitstream_memory_size.IsValid())
     return false;
 
   std::unique_ptr<base::SharedMemory> audio_memory(
       RenderThreadImpl::current()->HostAllocateSharedMemoryBuffer(
           total_audio_memory_size.ValueOrDie()));
   if (!audio_memory)
     return false;
   std::unique_ptr<ppapi::MediaStreamBufferManager> audio_buffer_manager(
       new ppapi::MediaStreamBufferManager(this));
-  if (!audio_buffer_manager->SetBuffers(kDefaultNumberOfAudioBuffers,
-                                        total_audio_buffer_size.ValueOrDie(),
-                                        std::move(audio_memory), false))
+  if (!audio_buffer_manager->SetBuffers(
+          kDefaultNumberOfAudioBuffers,
+          base::ValueOrDieForType<int32_t>(total_audio_buffer_size),
+          std::move(audio_memory), false))
     return false;
 
   for (int32_t i = 0; i < audio_buffer_manager->number_of_buffers(); ++i) {
     ppapi::MediaStreamBuffer::Audio* buffer =
         &(audio_buffer_manager->GetBufferPointer(i)->audio);
     buffer->header.size = total_audio_buffer_size.ValueOrDie();
     buffer->header.type = ppapi::MediaStreamBuffer::TYPE_AUDIO;
     buffer->sample_rate =
         static_cast<PP_AudioBuffer_SampleRate>(parameters.input_sample_rate);
     buffer->number_of_channels = parameters.channels;
     buffer->number_of_samples = samples_per_frame;
     buffer->data_size = audio_buffer_size.ValueOrDie();
   }
 
   std::unique_ptr<base::SharedMemory> bitstream_memory(
       RenderThreadImpl::current()->HostAllocateSharedMemoryBuffer(
           total_bitstream_memory_size.ValueOrDie()));
   if (!bitstream_memory)
     return false;
   std::unique_ptr<ppapi::MediaStreamBufferManager> bitstream_buffer_manager(
       new ppapi::MediaStreamBufferManager(this));
-  if (!bitstream_buffer_manager->SetBuffers(kDefaultNumberOfAudioBuffers,
-                                            bitstream_buffer_size.ValueOrDie(),
-                                            std::move(bitstream_memory), true))
+  if (!bitstream_buffer_manager->SetBuffers(
+          kDefaultNumberOfAudioBuffers,
+          base::ValueOrDieForType<int32_t>(bitstream_buffer_size),
+          std::move(bitstream_memory), true))
     return false;
 
   for (int32_t i = 0; i < bitstream_buffer_manager->number_of_buffers(); ++i) {
     ppapi::MediaStreamBuffer::Bitstream* buffer =
         &(bitstream_buffer_manager->GetBufferPointer(i)->bitstream);
     buffer->header.size = bitstream_buffer_size.ValueOrDie();
     buffer->header.type = ppapi::MediaStreamBuffer::TYPE_BITSTREAM;
   }
 
   audio_buffer_manager_.swap(audio_buffer_manager);
@@ skipping 82 matching lines @@
 }
 
 // static
 void PepperAudioEncoderHost::StopAudioEncoder(
     std::unique_ptr<AudioEncoderImpl> encoder,
     std::unique_ptr<ppapi::MediaStreamBufferManager> audio_buffer_manager,
     std::unique_ptr<ppapi::MediaStreamBufferManager> bitstream_buffer_manager) {
 }
 
 }  // namespace content