Remove webkit::ppapi::Resource.

webkit/plugins/ppapi/quota_file_io.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/plugins/ppapi/quota_file_io.h"
 
 #include <algorithm>
 
 #include "base/stl_util.h"
 #include "base/message_loop_proxy.h"
 #include "base/task.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
+#include "webkit/plugins/ppapi/resource_helper.h"
+#include "webkit/plugins/ppapi/resource_tracker.h"
 
 using base::PlatformFile;
 using base::PlatformFileError;
 using quota::StorageType;
 
 namespace webkit {
 namespace ppapi {
 
 namespace {
 StorageType PPFileSystemTypeToQuotaStorageType(PP_FileSystemType type) {
@@ skipping 61 matching lines @@
       DidFail(base::PLATFORM_FILE_ERROR_NO_SPACE);
       return;
     }
     if (is_will_operation_) {
       // Assuming the write will succeed.
       DidFinish(base::PLATFORM_FILE_OK, bytes_to_write_);
       return;
     }
     DCHECK(buffer_.get());
     if (!base::FileUtilProxy::Write(
-            quota_io_->instance_->delegate()->GetFileThreadMessageLoopProxy(),
+            quota_io_->GetPluginDelegate()->GetFileThreadMessageLoopProxy(),
             quota_io_->file_, offset_, buffer_.get(), bytes_to_write_,
             callback_factory_.NewCallback(&WriteOperation::DidFinish))) {
       DidFail(base::PLATFORM_FILE_ERROR_FAILED);
       return;
     }
   }
 
   virtual void DidFail(PlatformFileError error) OVERRIDE {
     DidFinish(error, 0);
   }
@@ skipping 52 matching lines @@
     DCHECK(quota_io_);
     if (quota_io_->CheckIfExceedsQuota(length_)) {
       DidFail(base::PLATFORM_FILE_ERROR_NO_SPACE);
       return;
     }
     if (is_will_operation_) {
       DidFinish(base::PLATFORM_FILE_OK);
       return;
     }
     if (!base::FileUtilProxy::Truncate(
-            quota_io_->instance_->delegate()->GetFileThreadMessageLoopProxy(),
+            quota_io_->GetPluginDelegate()->GetFileThreadMessageLoopProxy(),
             quota_io_->file_, length_,
             callback_factory_.NewCallback(&SetLengthOperation::DidFinish))) {
       DidFail(base::PLATFORM_FILE_ERROR_FAILED);
       return;
     }
   }
 
   virtual void DidFail(PlatformFileError error) OVERRIDE {
     DidFinish(error);
   }
 
  private:
   void DidFinish(PlatformFileError status) {
     quota_io_->DidSetLength(status, length_);
     DCHECK(callback_.get());
     callback_->Run(status);
     callback_.reset();
     delete this;
   }
 
   int64_t length_;
   scoped_ptr<StatusCallback> callback_;
   base::ScopedCallbackFactory<SetLengthOperation> callback_factory_;
 };
 
 // QuotaFileIO --------------------------------------------------------------
 
 QuotaFileIO::QuotaFileIO(
-    PluginInstance* instance,
+    PP_Instance instance,
     PlatformFile file,
     const GURL& file_url,
     PP_FileSystemType type)
-    : instance_(instance),
+    : pp_instance_(instance),
       file_(file),
       file_url_(file_url),
       storage_type_(PPFileSystemTypeToQuotaStorageType(type)),
       cached_file_size_(0),
       cached_available_space_(0),
       outstanding_quota_queries_(0),
       outstanding_errors_(0),
       max_written_offset_(0),
       inflight_operations_(0),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
-  DCHECK(instance_);
   DCHECK_NE(base::kInvalidPlatformFileValue, file_);
   DCHECK_NE(quota::kStorageTypeUnknown, storage_type_);
 }
 
 QuotaFileIO::~QuotaFileIO() {
   // Note that this doesn't dispatch pending callbacks.
   STLDeleteContainerPointers(pending_operations_.begin(),
                              pending_operations_.end());
   STLDeleteContainerPointers(pending_callbacks_.begin(),
                              pending_callbacks_.end());
@@ skipping 24 matching lines @@
       this, true, offset, NULL, bytes_to_write, callback);
   return RegisterOperationForQuotaChecks(op);
 }
 
 bool QuotaFileIO::WillSetLength(int64_t length, StatusCallback* callback) {
   DCHECK(pending_operations_.empty());
   SetLengthOperation* op = new SetLengthOperation(this, true, length, callback);
   return RegisterOperationForQuotaChecks(op);
 }
 
+PluginDelegate* QuotaFileIO::GetPluginDelegate() const {
+  PluginInstance* instance = ResourceTracker::Get()->GetInstance(pp_instance_);
+  if (instance)
+    return instance->delegate();
+  return NULL;
+}
+
 bool QuotaFileIO::RegisterOperationForQuotaChecks(
     PendingOperationBase* op_ptr) {
   scoped_ptr<PendingOperationBase> op(op_ptr);
   if (pending_operations_.empty()) {
     // This is the first pending quota check. Run querying the file size
     // and available space.
     outstanding_quota_queries_ = 0;
     outstanding_errors_ = 0;
 
     // Query the file size.
     ++outstanding_quota_queries_;
     if (!base::FileUtilProxy::GetFileInfoFromPlatformFile(
-            instance_->delegate()->GetFileThreadMessageLoopProxy(), file_,
+            GetPluginDelegate()->GetFileThreadMessageLoopProxy(), file_,
             callback_factory_.NewCallback(
                 &QuotaFileIO::DidQueryInfoForQuota))) {
       // This makes the call fail synchronously; we do not fire the callback
       // here but just delete the operation and return false.
       return false;
     }
 
     // Query the current available space.
     ++outstanding_quota_queries_;
-    instance_->delegate()->QueryAvailableSpace(
+    GetPluginDelegate()->QueryAvailableSpace(
         GURL(file_url_.path()).GetOrigin(), storage_type_,
         callback_factory_.NewCallback(&QuotaFileIO::DidQueryAvailableSpace));
   }
   pending_operations_.push_back(op.release());
   return true;
 }
 
 void QuotaFileIO::DidQueryInfoForQuota(
     base::PlatformFileError error_code,
     const base::PlatformFileInfo& file_info) {
@@ skipping 28 matching lines @@
 }
 
 bool QuotaFileIO::CheckIfExceedsQuota(int64_t new_file_size) const {
   DCHECK_GE(cached_file_size_, 0);
   DCHECK_GE(cached_available_space_, 0);
   return new_file_size - cached_file_size_ > cached_available_space_;
 }
 
 void QuotaFileIO::WillUpdate() {
   if (inflight_operations_++ == 0) {
-    instance_->delegate()->WillUpdateFile(file_url_);
+    GetPluginDelegate()->WillUpdateFile(file_url_);
     DCHECK_EQ(0, max_written_offset_);
   }
 }
 
 void QuotaFileIO::DidWrite(WriteOperation* op,
                            int64_t written_offset_end) {
   max_written_offset_ = std::max(max_written_offset_, written_offset_end);
   DCHECK_GT(inflight_operations_, 0);
   DCHECK(!pending_callbacks_.empty());
   // Fire callbacks for finished operations.
   while (!pending_callbacks_.empty()) {
     WriteOperation* op = static_cast<WriteOperation*>(
         pending_callbacks_.front());
     if (!op->finished())
       break;
     pending_callbacks_.pop_front();
     op->WillRunCallback();
   }
   // If we have no more pending writes, notify the browser that we did
   // update the file.
   if (--inflight_operations_ == 0) {
     DCHECK(pending_operations_.empty());
     int64_t growth = max_written_offset_ - cached_file_size_;
     growth = growth < 0 ? 0 : growth;
-    instance_->delegate()->DidUpdateFile(file_url_, growth);
+    GetPluginDelegate()->DidUpdateFile(file_url_, growth);
     max_written_offset_ = 0;
   }
 }
 
 void QuotaFileIO::DidSetLength(PlatformFileError error, int64_t new_file_size) {
   DCHECK_EQ(1, inflight_operations_);
   pending_callbacks_.pop_front();
   DCHECK(pending_callbacks_.empty());
   int64_t delta = (error != base::PLATFORM_FILE_OK) ? 0 :
       new_file_size - cached_file_size_;
-  instance_->delegate()->DidUpdateFile(file_url_, delta);
+  GetPluginDelegate()->DidUpdateFile(file_url_, delta);
   inflight_operations_ = 0;
 }
 
 }  // namespace ppapi
 }  // namespace webkit