Finish the base::Bind migration for webkit/media.

webkit/media/buffered_resource_loader.h

 // Copyright (c) 2011 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 WEBKIT_MEDIA_BUFFERED_RESOURCE_LOADER_H_
 #define WEBKIT_MEDIA_BUFFERED_RESOURCE_LOADER_H_
 
 #include <string>
 
 #include "base/callback.h"
@@ skipping 61 matching lines @@
   // - net::OK
   //   The request has started successfully.
   // - net::ERR_FAILED
   //   The request has failed because of an error with the network.
   // - net::ERR_INVALID_RESPONSE
   //   An invalid response is received from the server.
   // - (Anything else)
   //   An error code that indicates the request has failed.
   // |event_callback| is called when the response is completed, data is
   // received, the request is suspended or resumed.
-  virtual void Start(net::OldCompletionCallback* callback,
+  virtual void Start(const net::CompletionCallback& callback,
                      const base::Closure& event_callback,
                      WebKit::WebFrame* frame);
 
   // Stop this loader, cancels and request and release internal buffer.
   virtual void Stop();
 
   // Reads the specified |read_size| from |position| into |buffer| and when
   // the operation is done invoke |callback| with number of bytes read or an
   // error code. If necessary, will temporarily increase forward capacity of
   // buffer to accomodate an unusually large read.
   // |callback| is called with the following values:
   // - (Anything greater than or equal 0)
   //   Read was successful with the indicated number of bytes read.
   // - net::ERR_FAILED
   //   The read has failed because of an error with the network.
   // - net::ERR_CACHE_MISS
   //   The read was made too far away from the current buffered position.
   virtual void Read(int64 position, int read_size,
-                    uint8* buffer, net::OldCompletionCallback* callback);
+                    uint8* buffer, const net::CompletionCallback& callback);
 
   // Returns the position of the last byte buffered. Returns
   // |kPositionNotSpecified| if such value is not available.
   virtual int64 GetBufferedPosition();
 
   // Gets the content length in bytes of the instance after this loader has been
   // started. If this value is |kPositionNotSpecified|, then content length is
   // unknown.
   virtual int64 content_length();
 
@@ skipping 108 matching lines @@
   // Done with read. Invokes the read callback and reset parameters for the
   // read request.
   void DoneRead(int error);
 
   // Done with start. Invokes the start callback and reset it.
   void DoneStart(int error);
 
   // Calls |event_callback_| in terms of a network event.
   void NotifyNetworkEvent();
 
-  bool HasPendingRead() { return read_callback_.get() != NULL; }
+  bool HasPendingRead() { return !read_callback_.is_null(); }
 
   // Helper function that returns true if a range request was specified.
   bool IsRangeRequest() const;
 
   // Log everything interesting to |media_log_|.
   void Log();
 
   // A sliding window of buffer.
   scoped_ptr<media::SeekableBuffer> buffer_;
 
@@ skipping 20 matching lines @@
 
   GURL url_;
   int64 first_byte_position_;
   int64 last_byte_position_;
   bool single_origin_;
 
   // Callback method that listens to network events.
   base::Closure event_callback_;
 
   // Members used during request start.
-  scoped_ptr<net::OldCompletionCallback> start_callback_;
+  net::CompletionCallback start_callback_;
   int64 offset_;
   int64 content_length_;
   int64 instance_size_;
 
   // Members used during a read operation. They should be reset after each
   // read has completed or failed.
-  scoped_ptr<net::OldCompletionCallback> read_callback_;
+  net::CompletionCallback read_callback_;
   int64 read_position_;
   size_t read_size_;
   uint8* read_buffer_;
 
   // Offsets of the requested first byte and last byte in |buffer_|. They are
   // written by Read().
   int first_offset_;
   int last_offset_;
 
   // Used to ensure mocks for unittests are used instead of reset in Start().
   bool keep_test_loader_;
 
   // Bitrate of the media. Set to 0 if unknown.
   int bitrate_;
 
   // Playback rate of the media.
   float playback_rate_;
 
   scoped_refptr<media::MediaLog> media_log_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferedResourceLoader);
 };
 
 }  // namespace webkit_media
 
 #endif  // WEBKIT_MEDIA_BUFFERED_RESOURCE_LOADER_H_