net/websockets: Convert int types from basictypes.h to the ones from stdint.h

net/websockets/websocket_basic_stream.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 "net/websockets/websocket_basic_stream.h"
 
+#include <stdint.h>

[Adam Rice, 2015/10/13 08:32:51]

I prefer to have a space between the C includes and the C++ includes (but in
practice //net/websockets has a mixture of both, so this is a request, not a
requirement).

[wtc, 2015/10/13 17:12:17]

The Style Guide's recommendation changed in this regard. The example code in
the current Style Guide no longer has a blank line between the C and C++ system
header files:

https://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Names_and_Or...

So I am afraid that it is hard to ask people to follow the old style guide
recommendation.

[Adam Rice, 2015/10/13 17:21:49]

Understood. Request withdrawn.

 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"

[eroman, 2015/10/12 21:24:55]

It may be possible to remove basictypes.h in some cases (if the only thing it
was using was uint64 and friends)

[Adam Rice, 2015/10/13 08:32:51]

I am happy to have it removed in a separate CL (as long as it does get removed).
size_t requires <stdlib.h> and integer limits require <limits.h> or <limits>
depending on whether they are C-style or C++-style.

[wtc, 2015/10/13 17:12:17]

Yes, we should take the opportunity to find out if "base/basictypes.h" can be
removed or replaced by "base/macros.h" (for the DISALLOW_COPY_AND_ASSIGN
macro). This requires additional code inspection, but I consider it an integral
part of this work (because I think the goal is to eliminate "base/basictypes.h"
eventually).

[eroman, 2015/10/13 18:34:26]

This is certainly nice work to do, and can probably be done in bulk over Chrome
code using a tool like IWYU (would be rather labor intensive to do this
manually).

Worth seeing if we can get IWYU to run for Chromium's source code:
http://include-what-you-use.org/

If you are interested there were some bugs on file for this from years ago, not
sure what the latest status is.

[tfarina, 2015/10/13 18:44:32]

I talked with Kim Gräsman from iwyu back in March and got some results from
running it on tools/gn, but none were satisfatory. Now it seems there is a new
release from June, so we might give it another try. The integration with our
build system is certainly the complication point. You need to generate a
compilation database first, then pass it to python script, etc.

Something like:

$ ninja -C out/Release -t compdb cxx > out/Release/compile_commands.json
$ iwyu_tool.py -p compile_commands.json ../../tools/gn/gn_main.cc

But I had to manually edit compile_commands.json because of relative paths, a
mess.

Then the tools suggested things like this:
/usr/include/sched.h:30:10: fatal error: 'stddef.h' file not found
#include <stddef.h>
         ^

../../tools/gn/gn_main.cc should add these lines:
#include <debug/map.h>                  // for map
#include <debug/safe_iterator.h>        // for _Safe_iterator, operator!=
#include <stdlib.h>                     // for exit
#include <debug/safe_sequence.tcc>
#include <debug/vector>                 // for vector
#include <map>                          // for _Rb_tree_const_iterator
#include <string>                       // for string, allocator, etc
#include <utility>                      // for pair

Which is far from being good IMO.

[eroman, 2015/10/13 18:59:12]

Thanks for the update! That is too bad, it sounded promising from the project
description :)

 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/websockets/websocket_errors.h"
 #include "net/websockets/websocket_frame.h"
 #include "net/websockets/websocket_frame_parser.h"
 
 namespace net {
 
 namespace {
 
-// This uses type uint64 to match the definition of
+// This uses type uint64_t to match the definition of
 // WebSocketFrameHeader::payload_length in websocket_frame.h.
-const uint64 kMaxControlFramePayload = 125;
+const uint64_t kMaxControlFramePayload = 125;
 
 // The number of bytes to attempt to read at a time.
 // TODO(ricea): See if there is a better number or algorithm to fulfill our
 // requirements:
 //  1. We would like to use minimal memory on low-bandwidth or idle connections
 //  2. We would like to read as close to line speed as possible on
 //     high-bandwidth connections
 //  3. We can't afford to cause jank on the IO thread by copying large buffers
 //     around
 //  4. We would like to hit any sweet-spots that might exist in terms of network
 //     packet sizes / encryption block sizes / IPC alignment issues, etc.
 const int kReadBufferSize = 32 * 1024;
 
 typedef ScopedVector<WebSocketFrame>::const_iterator WebSocketFrameIterator;
 
 // Returns the total serialized size of |frames|. This function assumes that
 // |frames| will be serialized with mask field. This function forces the
 // masked bit of the frames on.
 int CalculateSerializedSizeAndTurnOnMaskBit(
     ScopedVector<WebSocketFrame>* frames) {
-  const uint64 kMaximumTotalSize = std::numeric_limits<int>::max();
+  const uint64_t kMaximumTotalSize = std::numeric_limits<int>::max();
 
-  uint64 total_size = 0;
+  uint64_t total_size = 0;
   for (WebSocketFrameIterator it = frames->begin(); it != frames->end(); ++it) {
     WebSocketFrame* frame = *it;
     // Force the masked bit on.
     frame->header.masked = true;
     // We enforce flow control so the renderer should never be able to force us
     // to cache anywhere near 2GB of frames.
-    uint64 frame_size = frame->header.payload_length +
-        GetWebSocketFrameHeaderSize(frame->header);
+    uint64_t frame_size = frame->header.payload_length +
+                          GetWebSocketFrameHeaderSize(frame->header);
     CHECK_LE(frame_size, kMaximumTotalSize - total_size)
         << "Aborting to prevent overflow";
     total_size += frame_size;
   }
   return static_cast<int>(total_size);
 }
 
 }  // namespace
 
 WebSocketBasicStream::WebSocketBasicStream(
@@ skipping 79 matching lines @@
     WebSocketMaskingKey mask = generate_websocket_masking_key_();
     int result =
         WriteWebSocketFrameHeader(frame->header, &mask, dest, remaining_size);
     DCHECK_NE(ERR_INVALID_ARGUMENT, result)
         << "WriteWebSocketFrameHeader() says that " << remaining_size
         << " is not enough to write the header in. This should not happen.";
     CHECK_GE(result, 0) << "Potentially security-critical check failed";
     dest += result;
     remaining_size -= result;
 
-    CHECK_LE(frame->header.payload_length, static_cast<uint64>(remaining_size));
+    CHECK_LE(frame->header.payload_length,
+             static_cast<uint64_t>(remaining_size));
     const int frame_size = static_cast<int>(frame->header.payload_length);
     if (frame_size > 0) {
       const char* const frame_data = frame->data->data();
       std::copy(frame_data, frame_data + frame_size, dest);
       MaskWebSocketFramePayload(mask, 0, dest, frame_size);
       dest += frame_size;
       remaining_size -= frame_size;
     }
   }
   DCHECK_EQ(0, remaining_size) << "Buffer size calculation was wrong; "
@@ skipping 171 matching lines @@
       DCHECK(is_final_chunk);
       *frame = CreateFrame(is_final_chunk, body);
       return OK;
     }
   }
 
   // Apply basic sanity checks to the |payload_length| field from the frame
   // header. A check for exact equality can only be used when the whole frame
   // arrives in one chunk.
   DCHECK_GE(current_frame_header_->payload_length,
-            base::checked_cast<uint64>(chunk_size));
+            base::checked_cast<uint64_t>(chunk_size));
   DCHECK(!is_first_chunk || !is_final_chunk ||
          current_frame_header_->payload_length ==
-             base::checked_cast<uint64>(chunk_size));
+             base::checked_cast<uint64_t>(chunk_size));
 
   // Convert the chunk to a complete frame.
   *frame = CreateFrame(is_final_chunk, data_buffer);
   return OK;
 }
 
 scoped_ptr<WebSocketFrame> WebSocketBasicStream::CreateFrame(
     bool is_final_chunk,
     const scoped_refptr<IOBufferWithSize>& data) {
   scoped_ptr<WebSocketFrame> result_frame;
@@ skipping 49 matching lines @@
                                           const CompletionCallback& callback,
                                           int result) {
   result = HandleReadResult(result, frames);
   if (result == ERR_IO_PENDING)
     result = ReadFrames(frames, callback);
   if (result != ERR_IO_PENDING)
     callback.Run(result);
 }
 
 }  // namespace net