Leak fix in FileSystemOperationUnitTest.

webkit/fileapi/file_system_operation_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 "webkit/fileapi/file_system_operation.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ skipping 70 matching lines @@
   const StorageType type_;
   int64 usage_;
   int64 quota_;
   int accessed_;
 };
 
 class MockQuotaManagerProxy : public QuotaManagerProxy {
  public:
   explicit MockQuotaManagerProxy(QuotaManager* quota_manager)
       : QuotaManagerProxy(quota_manager,
-                          base::MessageLoopProxy::CreateForCurrentThread()) {}
+                          base::MessageLoopProxy::CreateForCurrentThread()),
+        registered_client_(NULL) {
+  }
+
+  virtual ~MockQuotaManagerProxy() {
+    EXPECT_FALSE(registered_client_);
+  }
+
+  virtual void RegisterClient(QuotaClient* client) {
+    EXPECT_FALSE(registered_client_);
+    registered_client_ = client;
+  }
+
+  void SimulateQuotaManagerDestroyed() {
+    if (registered_client_) {
+      // We cannot call this in the destructor as the client (indirectly)
+      // holds a refptr of the proxy.
+      registered_client_->OnQuotaManagerDestroyed();
+      registered_client_ = NULL;
+    }
+  }
 
   // We don't mock them.
-  virtual void RegisterClient(QuotaClient* client) OVERRIDE {}
   virtual void NotifyOriginInUse(const GURL& origin) OVERRIDE {}
   virtual void NotifyOriginNoLongerInUse(const GURL& origin) OVERRIDE {}
 
   virtual void NotifyStorageAccessed(QuotaClient::ID client_id,
                                      const GURL& origin,
                                      StorageType type) OVERRIDE {
     mock_manager()->RecordStorageAccessed(origin, type);
   }
 
   virtual void NotifyStorageModified(QuotaClient::ID client_id,
                                      const GURL& origin,
                                      StorageType type,
                                      int64 delta) OVERRIDE {
     mock_manager()->UpdateUsage(origin, type, delta);
   }
 
   int storage_accessed_count() const {
     return mock_manager()->accessed_;
   }
 
   void SetQuota(const GURL& origin, StorageType type, int64 quota) {
     mock_manager()->SetQuota(origin, type, quota);
   }
 
  private:
   MockQuotaManager* mock_manager() const {
     return static_cast<MockQuotaManager*>(quota_manager());
   }
+  QuotaClient* registered_client_;
 };
 
 FilePath ASCIIToFilePath(const std::string& str) {
   return FilePath().AppendASCII(str);
 }
 
 }  // namespace (anonymous)
 
 // Test class for FileSystemOperation.  Note that this just tests low-level
 // operations but doesn't test OpenFileSystem.
@@ skipping 147 matching lines @@
       base_dir, test_helper_.origin(), test_helper_.storage_type());
   quota_manager_proxy_ = new MockQuotaManagerProxy(quota_manager_.get());
   test_helper_.SetUp(base_dir,
                      false /* incognito */,
                      false /* unlimited quota */,
                      quota_manager_proxy_.get(),
                      LocalFileSystemFileUtil::GetInstance());
 }
 
 void FileSystemOperationTest::TearDown() {
+  // Let the client go away before dropping a ref of the quota manager proxy.
+  quota_manager_proxy()->SimulateQuotaManagerDestroyed();
   quota_manager_ = NULL;
   quota_manager_proxy_ = NULL;
   test_helper_.TearDown();
 }
 
 FileSystemOperation* FileSystemOperationTest::operation() {
   return test_helper_.NewOperation(new MockDispatcher(this));
 }
 
 TEST_F(FileSystemOperationTest, TestMoveFailureSrcDoesntExist) {
@@ skipping 624 matching lines @@
 
   operation()->Truncate(URLForPath(file_path), 11);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, status());
 
   EXPECT_TRUE(file_util::GetFileInfo(PlatformPath(file_path), &info));
   EXPECT_EQ(10, info.size);
 }
 
 }  // namespace fileapi