Type conversion fixes, media/ edition.

media/cast/logging/log_serializer.cc

 // Copyright 2014 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.
 //
 // The serialization format is as follows:
 //   16-bit integer describing the following LogMetadata proto size in bytes.
 //   The LogMetadata proto.
 //   32-bit integer describing number of frame events.
 //   (The following repeated for number of frame events):
 //     16-bit integer describing the following AggregatedFrameEvent proto size
@@ skipping 29 matching lines @@
 bool DoSerializeEvents(const LogMetadata& metadata,
                        const FrameEventList& frame_events,
                        const PacketEventList& packet_events,
                        const int max_output_bytes,
                        char* output,
                        int* output_bytes) {
   base::BigEndianWriter writer(output, max_output_bytes);
 
   int proto_size = metadata.ByteSize();
   DCHECK(proto_size <= kMaxSerializedProtoBytes);
-  if (!writer.WriteU16(proto_size))
+  if (!writer.WriteU16(static_cast<uint16>(proto_size)))
     return false;
   if (!metadata.SerializeToArray(writer.ptr(), writer.remaining()))
     return false;
   if (!writer.Skip(proto_size))
     return false;
 
   RtpTimestamp prev_rtp_timestamp = 0;
   for (media::cast::FrameEventList::const_iterator it = frame_events.begin();
        it != frame_events.end();
        ++it) {
     media::cast::proto::AggregatedFrameEvent frame_event(**it);
 
     // Adjust relative RTP timestamp so that it is relative to previous frame,
     // rather than relative to first RTP timestamp.
     // This is done to improve encoding size.
     RtpTimestamp old_relative_rtp_timestamp =
         frame_event.relative_rtp_timestamp();
     frame_event.set_relative_rtp_timestamp(
         old_relative_rtp_timestamp - prev_rtp_timestamp);
     prev_rtp_timestamp = old_relative_rtp_timestamp;
 
     proto_size = frame_event.ByteSize();
     DCHECK(proto_size <= kMaxSerializedProtoBytes);
 
     // Write size of the proto, then write the proto.
-    if (!writer.WriteU16(proto_size))
+    if (!writer.WriteU16(static_cast<uint16>(proto_size)))
       return false;
     if (!frame_event.SerializeToArray(writer.ptr(), writer.remaining()))
       return false;
     if (!writer.Skip(proto_size))
       return false;
   }
 
   // Write packet events.
   prev_rtp_timestamp = 0;
   for (media::cast::PacketEventList::const_iterator it = packet_events.begin();
        it != packet_events.end();
        ++it) {
     media::cast::proto::AggregatedPacketEvent packet_event(**it);
     RtpTimestamp old_relative_rtp_timestamp =
         packet_event.relative_rtp_timestamp();
     packet_event.set_relative_rtp_timestamp(
         old_relative_rtp_timestamp - prev_rtp_timestamp);
     prev_rtp_timestamp = old_relative_rtp_timestamp;
 
     proto_size = packet_event.ByteSize();
     DCHECK(proto_size <= kMaxSerializedProtoBytes);
 
     // Write size of the proto, then write the proto.
-    if (!writer.WriteU16(proto_size))
+    if (!writer.WriteU16(static_cast<uint16>(proto_size)))
       return false;
     if (!packet_event.SerializeToArray(writer.ptr(), writer.remaining()))
       return false;
     if (!writer.Skip(proto_size))
       return false;
   }
 
   *output_bytes = max_output_bytes - writer.remaining();
   return true;
 }
@@ skipping 70 matching lines @@
                              frame_events,
                              packet_events,
                              max_output_bytes,
                              output,
                              output_bytes);
   }
 }
 
 }  // namespace cast
 }  // namespace media