Switch to standard integer types in media/.

media/blink/buffered_data_source.h

 // 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.
 
 #ifndef MEDIA_BLINK_BUFFERED_DATA_SOURCE_H_
 #define MEDIA_BLINK_BUFFERED_DATA_SOURCE_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 10 matching lines @@
 namespace base {
 class SingleThreadTaskRunner;
 }
 
 namespace media {
 class MediaLog;
 
 class MEDIA_BLINK_EXPORT BufferedDataSourceHost {
  public:
   // Notify the host of the total size of the media file.
-  virtual void SetTotalBytes(int64 total_bytes) = 0;
+  virtual void SetTotalBytes(int64_t total_bytes) = 0;
 
   // Notify the host that byte range [start,end] has been buffered.
   // TODO(fischman): remove this method when demuxing is push-based instead of
   // pull-based.  http://crbug.com/131444
-  virtual void AddBufferedByteRange(int64 start, int64 end) = 0;
+  virtual void AddBufferedByteRange(int64_t start, int64_t end) = 0;
 
  protected:
   virtual ~BufferedDataSourceHost() {}
 };
 
 // This interface is temporary and will go away once MultibufferDataSource
 // has been fully evaluated.
 class BufferedDataSourceInterface : public DataSource {
  public:
   // Used to specify video preload states. They are "hints" to the browser about
@@ skipping 130 matching lines @@
   // If already deferred, connections will be immediately closed.
   void OnBufferingHaveEnough() override;
 
   // Returns an estimate of the number of bytes held by the data source.
   int64_t GetMemoryUsage() const override;
 
   // DataSource implementation.
   // Called from demuxer thread.
   void Stop() override;
 
-  void Read(int64 position,
+  void Read(int64_t position,
             int size,
-            uint8* data,
+            uint8_t* data,
             const DataSource::ReadCB& read_cb) override;
-  bool GetSize(int64* size_out) override;
+  bool GetSize(int64_t* size_out) override;
   bool IsStreaming() override;
   void SetBitrate(int bitrate) override;
 
  protected:
   // A factory method to create a BufferedResourceLoader based on the read
   // parameters. We can override this file to object a mock
   // BufferedResourceLoader for testing.
   virtual BufferedResourceLoader* CreateResourceLoader(
-      int64 first_byte_position, int64 last_byte_position);
+      int64_t first_byte_position,
+      int64_t last_byte_position);
 
  private:
   friend class BufferedDataSourceTest;
 
   // Task posted to perform actual reading on the render thread.
   void ReadTask();
 
   // Cancels oustanding callbacks and sets |stop_signal_received_|. Safe to call
   // from any thread.
   void StopInternal_Locked();
@@ skipping 14 matching lines @@
   // BufferedResourceLoader::Start() callback for subsequent loads (i.e.,
   // when accessing ranges that are outside initial buffered region).
   void PartialReadStartCallback(BufferedResourceLoader::Status status);
 
   // Returns true if we can accept the new partial response.
   bool CheckPartialResponseURL(const GURL& partial_response_original_url) const;
 
   // BufferedResourceLoader callbacks.
   void ReadCallback(BufferedResourceLoader::Status status, int bytes_read);
   void LoadingStateChangedCallback(BufferedResourceLoader::LoadingState state);
-  void ProgressCallback(int64 position);
+  void ProgressCallback(int64_t position);
 
   // Update |loader_|'s deferring strategy.
   void UpdateDeferStrategy();
 
   // URL of the resource requested.
   GURL url_;
   // crossorigin attribute on the corresponding HTML media element, if any.
   BufferedResourceLoader::CORSMode cors_mode_;
 
   // The total size of the resource. Set during StartCallback() if the size is
   // known, otherwise it will remain kPositionNotSpecified until the size is
   // determined by reaching EOF.
-  int64 total_bytes_;
+  int64_t total_bytes_;
 
   // This value will be true if this data source can only support streaming.
   // i.e. range request is not supported.
   bool streaming_;
 
   // A webframe for loading.
   blink::WebFrame* frame_;
 
   // A resource loader for the media resource.
   scoped_ptr<BufferedResourceLoader> loader_;
 
   // Callback method from the pipeline for initialization.
   InitializeCB init_cb_;
 
   // Read parameters received from the Read() method call. Must be accessed
   // under |lock_|.
   class ReadOperation;
   scoped_ptr<ReadOperation> read_op_;
 
   // This buffer is intermediate, we use it for BufferedResourceLoader to write
   // to. And when read in BufferedResourceLoader is done, we copy data from
   // this buffer to |read_buffer_|. The reason for an additional copy is that
   // we don't own |read_buffer_|. But since the read operation is asynchronous,
   // |read_buffer| can be destroyed at any time, so we only copy into
   // |read_buffer| in the final step when it is safe.
   // Memory is allocated for this member during initialization of this object
   // because we want buffer to be passed into BufferedResourceLoader to be
   // always non-null. And by initializing this member with a default size we can
   // avoid creating zero-sized buffered if the first read has zero size.
-  std::vector<uint8> intermediate_read_buffer_;
+  std::vector<uint8_t> intermediate_read_buffer_;
 
   // The task runner of the render thread.
   const scoped_refptr<base::SingleThreadTaskRunner> render_task_runner_;
 
   // Protects |stop_signal_received_| and |read_op_|.
   base::Lock lock_;
 
   // Whether we've been told to stop via Abort() or Stop().
   bool stop_signal_received_;
 
@@ skipping 33 matching lines @@
   // reaching into this class from multiple threads to attain a WeakPtr.
   base::WeakPtr<BufferedDataSource> weak_ptr_;
   base::WeakPtrFactory<BufferedDataSource> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferedDataSource);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BLINK_BUFFERED_DATA_SOURCE_H_