Enable size_t to int truncation warnings in PPAPI

ppapi/examples/video_decode/video_decode_dev.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 <string.h>
 
 #include <iostream>
 #include <list>
 #include <map>
 #include <set>
@@ skipping 323 matching lines @@
   if (encoded_data_next_pos_to_decode_ == kDataLen) {
     ++encoded_data_next_pos_to_decode_;
     pp::CompletionCallback cb = callback_factory_.NewCallback(
         &VideoDecodeDemoInstance::DecoderClient::DecoderFlushDone);
     decoder_->Flush(cb);
     return;
   }
   size_t start_pos = encoded_data_next_pos_to_decode_;
   size_t end_pos;
   GetNextNALUBoundary(start_pos, &end_pos);
-  pp::Buffer_Dev* buffer = new pp::Buffer_Dev(gles2_, end_pos - start_pos);
+  pp::Buffer_Dev* buffer = new pp::Buffer_Dev(
+      gles2_, static_cast<uint32_t>(end_pos - start_pos));
   PP_VideoBitstreamBuffer_Dev bitstream_buffer;
   int id = ++next_bitstream_buffer_id_;
   bitstream_buffer.id = id;
-  bitstream_buffer.size = end_pos - start_pos;
+  bitstream_buffer.size = static_cast<uint32_t>(end_pos - start_pos);
   bitstream_buffer.data = buffer->pp_resource();
   memcpy(buffer->data(), kData + start_pos, end_pos - start_pos);
   assert(bitstream_buffers_by_id_.insert(std::make_pair(id, buffer)).second);
 
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(
           &VideoDecodeDemoInstance::DecoderClient::DecoderBitstreamDone, id);
   assert(bitstream_ids_at_decoder_.insert(id).second);
   encoded_data_next_pos_to_decode_ = end_pos;
   decoder_->Decode(bitstream_buffer, cb);
@@ skipping 271 matching lines @@
       CreateProgram(kVertexShader, kFragmentShaderRectangle);
 }
 
 Shader VideoDecodeDemoInstance::CreateProgram(const char* vertex_shader,
                                               const char* fragment_shader) {
   Shader shader;
 
   // Create shader program.
   shader.program = gles2_if_->CreateProgram(context_->pp_resource());
   CreateShader(shader.program, GL_VERTEX_SHADER, vertex_shader,
-               strlen(vertex_shader));
+               static_cast<int>(strlen(vertex_shader)));
   CreateShader(shader.program, GL_FRAGMENT_SHADER, fragment_shader,
-               strlen(fragment_shader));
+               static_cast<int>(strlen(fragment_shader)));
   gles2_if_->LinkProgram(context_->pp_resource(), shader.program);
   gles2_if_->UseProgram(context_->pp_resource(), shader.program);
   gles2_if_->Uniform1i(
       context_->pp_resource(),
       gles2_if_->GetUniformLocation(
           context_->pp_resource(), shader.program, "s_texture"), 0);
   assertNoGLError();
 
   shader.texcoord_scale_location = gles2_if_->GetUniformLocation(
       context_->pp_resource(), shader.program, "v_scale");
@@ skipping 26 matching lines @@
   gles2_if_->DeleteShader(context_->pp_resource(), shader);
 }
 }  // anonymous namespace
 
 namespace pp {
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new VideoDecodeDemoModule();
 }
 }  // namespace pp