base::Bind: Convert FileUtilProxy::WriteCallback.

webkit/plugins/ppapi/quota_file_io_unittest.cc

 // 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.
 
 #include <deque>
 #include <limits>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 17 matching lines @@
 
 namespace {
 class QuotaMockPluginDelegate : public MockPluginDelegate {
  public:
   typedef PluginDelegate::AvailableSpaceCallback Callback;
 
   QuotaMockPluginDelegate()
       : available_space_(0),
         will_update_count_(0),
         file_thread_(MessageLoopProxy::current()),
-        weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+        ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   }
   virtual ~QuotaMockPluginDelegate() {}
 
   virtual scoped_refptr<MessageLoopProxy> GetFileThreadMessageLoopProxy() {
     return file_thread_;
   }
 
   virtual void QueryAvailableSpace(
       const GURL& origin,
       quota::StorageType type,
       const Callback& callback) OVERRIDE {
-    DCHECK(!callback.is_null());
+    DCHECK_EQ(false, callback.is_null());
     MessageLoopProxy::current()->PostTask(
         FROM_HERE, base::Bind(
             &QuotaMockPluginDelegate::RunAvailableSpaceCallback,
-            weak_ptr_factory_.GetWeakPtr(),
-            callback));
+            weak_factory_.GetWeakPtr(), callback));
   }
 
   virtual void WillUpdateFile(const GURL& file_path) OVERRIDE {
     file_path_ = file_path;
     ++will_update_count_;
   }
 
   virtual void DidUpdateFile(const GURL& file_path, int64_t delta) OVERRIDE {
     ASSERT_EQ(file_path_, file_path);
     ASSERT_GT(will_update_count_, 0);
     --will_update_count_;
     available_space_ -= delta;
   }
 
   void set_available_space(int64 available) { available_space_ = available; }
   int64_t available_space() const { return available_space_; }
 
  private:
   void RunAvailableSpaceCallback(const Callback& callback) {
     callback.Run(available_space_);
   }
 
   int64_t available_space_;
   int will_update_count_;
   GURL file_path_;
   scoped_refptr<MessageLoopProxy> file_thread_;
-  base::WeakPtrFactory<QuotaMockPluginDelegate> weak_ptr_factory_;
+  base::WeakPtrFactory<QuotaMockPluginDelegate> weak_factory_;
 };
 }  // namespace
 
 class QuotaFileIOTest : public PpapiUnittest {
  public:
   QuotaFileIOTest()
-      : callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
+      : ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)),
+        ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {}
 
   virtual void SetUp() OVERRIDE {
     PpapiUnittest::SetUp();
     ASSERT_TRUE(dir_.CreateUniqueTempDir());
     FilePath path;
     ASSERT_TRUE(file_util::CreateTemporaryFileInDir(dir_.path(), &path));
     int file_flags = base::PLATFORM_FILE_OPEN |
                      base::PLATFORM_FILE_READ |
                      base::PLATFORM_FILE_WRITE |
                      base::PLATFORM_FILE_WRITE_ATTRIBUTES;
@@ skipping 16 matching lines @@
     PpapiUnittest::TearDown();
   }
 
  protected:
   virtual MockPluginDelegate* NewPluginDelegate() OVERRIDE {
     return static_cast<MockPluginDelegate*>(new QuotaMockPluginDelegate);
   }
 
   void WriteTestBody(bool will_operation) {
     // Attempt to write zero bytes.
-    EXPECT_FALSE(quota_file_io_->Write(0, "data", 0,
-                                       callback_factory_.NewCallback(
-                                           &QuotaFileIOTest::DidWrite)));
+    EXPECT_FALSE(quota_file_io_->Write(
+        0, "data", 0,
+        base::Bind(&QuotaFileIOTest::DidWrite, weak_factory_.GetWeakPtr())));
     // Attempt to write negative number of bytes.
-    EXPECT_FALSE(quota_file_io_->Write(0, "data",
-                                       std::numeric_limits<int32_t>::min(),
-                                       callback_factory_.NewCallback(
-                                           &QuotaFileIOTest::DidWrite)));
+    EXPECT_FALSE(quota_file_io_->Write(
+        0, "data", std::numeric_limits<int32_t>::min(),
+        base::Bind(&QuotaFileIOTest::DidWrite, weak_factory_.GetWeakPtr())));
 
     quota_plugin_delegate()->set_available_space(100);
     std::string read_buffer;
 
     // Write 8 bytes at offset 0 (-> length=8).
     std::string data("12345678");
     Write(0, data, will_operation);
     MessageLoop::current()->RunAllPending();
     ASSERT_EQ(1U, num_results());
     EXPECT_EQ(static_cast<int>(data.size()), bytes_written().front());
@@ skipping 204 matching lines @@
     reset_results();
   }
 
   QuotaMockPluginDelegate* quota_plugin_delegate() {
     return static_cast<QuotaMockPluginDelegate*>(delegate());
   }
 
   void Write(int64_t offset, const std::string& data, bool will_operation) {
     if (will_operation) {
       ASSERT_TRUE(quota_file_io_->WillWrite(
-                      offset, data.size(),
-                      callback_factory_.NewCallback(
-                          &QuotaFileIOTest::DidWrite)));
+          offset, data.size(),
+          base::Bind(&QuotaFileIOTest::DidWrite, weak_factory_.GetWeakPtr())));
     } else {
       ASSERT_TRUE(quota_file_io_->Write(
-                      offset, data.c_str(), data.size(),
-                      callback_factory_.NewCallback(
-                          &QuotaFileIOTest::DidWrite)));
+          offset, data.c_str(), data.size(),
+          base::Bind(&QuotaFileIOTest::DidWrite, weak_factory_.GetWeakPtr())));
     }
   }
 
   void SetLength(int64_t length, bool will_operation) {
     if (will_operation) {
       ASSERT_TRUE(quota_file_io_->WillSetLength(
                       length,
                       callback_factory_.NewCallback(
                           &QuotaFileIOTest::DidSetLength)));
     } else {
@@ skipping 51 matching lines @@
     EXPECT_TRUE(base::TruncatePlatformFile(file_, length));
   }
 
  private:
   ScopedTempDir dir_;
   PlatformFile file_;
   scoped_ptr<QuotaFileIO> quota_file_io_;
   std::deque<int> bytes_written_;
   std::deque<PlatformFileError> status_;
   base::ScopedCallbackFactory<QuotaFileIOTest> callback_factory_;
+  base::WeakPtrFactory<QuotaFileIOTest> weak_factory_;
 };
 
 TEST_F(QuotaFileIOTest, Write) {
   WriteTestBody(false);
 }
 
 TEST_F(QuotaFileIOTest, WillWrite) {
   WriteTestBody(true);
 }
 
@@ skipping 49 matching lines @@
   pop_result();
 
   EXPECT_EQ(22 - 15, quota_plugin_delegate()->available_space());
   EXPECT_EQ(15, GetPlatformFileSize());
   ReadPlatformFile(&read_buffer);
   EXPECT_EQ("123355559012345", read_buffer);
 }
 
 }  // namespace ppapi
 }  // namespace webkit