Switch to standard integer types in net/.

net/url_request/url_request_job.h

 // 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.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_JOB_H_
 #define NET_URL_REQUEST_URL_REQUEST_JOB_H_
 
 #include <stdint.h>
 
 #include <string>
@@ skipping 196 matching lines @@
   // Continue with the network request.
   virtual void ResumeNetworkStart();
 
   void FollowDeferredRedirect();
 
   // Returns true if the Job is done producing response data and has called
   // NotifyDone on the request.
   bool is_done() const { return done_; }
 
   // Get/Set expected content size
-  int64 expected_content_size() const { return expected_content_size_; }
-  void set_expected_content_size(const int64& size) {
+  int64_t expected_content_size() const { return expected_content_size_; }
+  void set_expected_content_size(const int64_t& size) {
     expected_content_size_ = size;
   }
 
   // Whether we have processed the response for that request yet.
   bool has_response_started() const { return has_handled_response_; }
 
   // These methods are not applicable to all connections.
   virtual bool GetMimeType(std::string* mime_type) const;
   virtual int GetResponseCode() const;
 
@@ skipping 109 matching lines @@
   const URLRequestStatus GetStatus();
 
   // Set the status of the job.
   void SetStatus(const URLRequestStatus& status);
 
   // Set the proxy server that was used, if any.
   void SetProxyServer(const HostPortPair& proxy_server);
 
   // The number of bytes read before passing to the filter. This value reflects
   // bytes read even when there is no filter.
-  int64 prefilter_bytes_read() const { return prefilter_bytes_read_; }
+  int64_t prefilter_bytes_read() const { return prefilter_bytes_read_; }
 
   // The number of bytes read after passing through the filter. This value
   // reflects bytes read even when there is no filter.
-  int64 postfilter_bytes_read() const { return postfilter_bytes_read_; }
+  int64_t postfilter_bytes_read() const { return postfilter_bytes_read_; }
 
   // Turns an integer result code into an Error and a count of bytes read.
   // The semantics are:
   //   |result| >= 0: |*error| == OK, |*count| == |result|
   //   |result| < 0: |*error| = |result|, |*count| == 0
   static void ConvertResultToError(int result, Error* error, int* count);
 
   // Completion callback for raw reads. See |ReadRawData| for details.
   // |bytes_read| is either >= 0 to indicate a successful read and count of
   // bytes read, or < 0 to indicate an error.
@@ skipping 56 matching lines @@
   // Notify the network delegate that more bytes have been received or sent over
   // the network, if bytes have been received or sent since the previous
   // notification.
   void MaybeNotifyNetworkBytes();
 
   // Indicates that the job is done producing data, either it has completed
   // all the data or an error has been encountered. Set exclusively by
   // NotifyDone so that it is kept in sync with the request.
   bool done_;
 
-  int64 prefilter_bytes_read_;
-  int64 postfilter_bytes_read_;
+  int64_t prefilter_bytes_read_;
+  int64_t postfilter_bytes_read_;
 
   // The data stream filter which is enabled on demand.
   scoped_ptr<Filter> filter_;
 
   // If the filter filled its output buffer, then there is a change that it
   // still has internal data to emit, and this flag is set.
   bool filter_needs_more_output_space_;
 
   // When we filter data, we receive data into the filter buffers.  After
   // processing the filtered data, we return the data in the caller's buffer.
   // While the async IO is in progress, we save the user buffer here, and
   // when the IO completes, we fill this in.
   scoped_refptr<IOBuffer> filtered_read_buffer_;
   int filtered_read_buffer_len_;
 
   // We keep a pointer to the read buffer while asynchronous reads are
   // in progress, so we are able to pass those bytes to job observers.
   scoped_refptr<IOBuffer> raw_read_buffer_;
 
   // Used by HandleResponseIfNecessary to track whether we've sent the
   // OnResponseStarted callback and potentially redirect callbacks as well.
   bool has_handled_response_;
 
   // Expected content size
-  int64 expected_content_size_;
+  int64_t expected_content_size_;
 
   // Set when a redirect is deferred.
   RedirectInfo deferred_redirect_info_;
 
   // The network delegate to use with this request, if any.
   NetworkDelegate* network_delegate_;
 
   // The value from GetTotalReceivedBytes() the last time
   // MaybeNotifyNetworkBytes() was called. Used to calculate how bytes have been
   // newly received since the last notification.
   int64_t last_notified_total_received_bytes_;
 
   // The value from GetTotalSentBytes() the last time MaybeNotifyNetworkBytes()
   // was called. Used to calculate how bytes have been newly sent since the last
   // notification.
   int64_t last_notified_total_sent_bytes_;
 
   base::WeakPtrFactory<URLRequestJob> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestJob);
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_JOB_H_