Pepper quota support

content/renderer/pepper_plugin_delegate_impl.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 "content/renderer/pepper_plugin_delegate_impl.h"
 
 #include <cmath>
 #include <queue>
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util_proxy.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_split.h"
 #include "base/sync_socket.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "content/common/child_process_messages.h"
 #include "content/common/child_process.h"
 #include "content/common/child_thread.h"
 #include "content/common/content_switches.h"
 #include "content/common/file_system/file_system_dispatcher.h"
 #include "content/common/media/audio_messages.h"
 #include "content/common/pepper_file_messages.h"
 #include "content/common/pepper_plugin_registry.h"
 #include "content/common/pepper_messages.h"
+#include "content/common/quota_dispatcher.h"
 #include "content/common/view_messages.h"
 #include "content/renderer/content_renderer_client.h"
 #include "content/renderer/gpu/command_buffer_proxy.h"
 #include "content/renderer/gpu/gpu_channel_host.h"
 #include "content/renderer/gpu/renderer_gl_context.h"
 #include "content/renderer/gpu/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/renderer/media/audio_message_filter.h"
 #include "content/renderer/p2p/p2p_transport_impl.h"
 #include "content/renderer/pepper_platform_context_3d_impl.h"
 #include "content/renderer/pepper_platform_video_decoder_impl.h"
@@ skipping 310 matching lines @@
     pp::proxy::HostDispatcher::SetForInstance(instance, dispatcher_.get());
   }
   virtual void RemoveInstance(PP_Instance instance) {
     pp::proxy::HostDispatcher::RemoveForInstance(instance);
   }
 
  private:
   scoped_ptr<pp::proxy::HostDispatcher> dispatcher_;
 };
 
+class QuotaCallbackTranslator : public QuotaDispatcher::Callback {
+ public:
+  typedef webkit::ppapi::PluginDelegate::AvailableSpaceCallback PluginCallback;
+  QuotaCallbackTranslator(PluginCallback* callback) : callback_(callback) {}
+  virtual void DidQueryStorageUsageAndQuota(int64 usage, int64 quota) OVERRIDE {
+    callback_->Run(std::max(static_cast<int64>(0), quota - usage));
+  }
+  virtual void DidGrantStorageQuota(int64 granted_quota) OVERRIDE {
+    NOTREACHED();
+  }
+  virtual void DidFail(quota::QuotaStatusCode error) OVERRIDE {
+    callback_->Run(0);
+  }
+
+ private:
+  scoped_ptr<PluginCallback> callback_;
+};
+
 }  // namespace
 
 bool DispatcherWrapper::Init(
     RenderView* render_view,
     base::ProcessHandle plugin_process_handle,
     const IPC::ChannelHandle& channel_handle,
     PP_Module pp_module,
     pp::proxy::Dispatcher::GetInterfaceFunc local_get_interface) {
   dispatcher_.reset(new pp::proxy::HostDispatcher(
       plugin_process_handle, pp_module, local_get_interface));
@@ skipping 539 matching lines @@
 }
 
 void PepperPluginDelegateImpl::OnAsyncFileOpened(
     base::PlatformFileError error_code,
     base::PlatformFile file,
     int message_id) {
   AsyncOpenFileCallback* callback =
       messages_waiting_replies_.Lookup(message_id);
   DCHECK(callback);
   messages_waiting_replies_.Remove(message_id);
-  callback->Run(error_code, base::PassPlatformFile(&file));
+  callback->Run(error_code, base::PassPlatformFile(&file), -1);
   // Make sure we won't leak file handle if the requester has died.
   if (file != base::kInvalidPlatformFileValue)
     base::FileUtilProxy::Close(GetFileThreadMessageLoopProxy(), file, NULL);
   delete callback;
 }
 
 void PepperPluginDelegateImpl::OnSetFocus(bool has_focus) {
   for (std::set<webkit::ppapi::PluginInstance*>::iterator i =
          active_instances_.begin();
        i != active_instances_.end(); ++i)
@@ skipping 63 matching lines @@
 }
 
 bool PepperPluginDelegateImpl::ReadDirectory(
     const GURL& directory_path,
     fileapi::FileSystemCallbackDispatcher* dispatcher) {
   FileSystemDispatcher* file_system_dispatcher =
       ChildThread::current()->file_system_dispatcher();
   return file_system_dispatcher->ReadDirectory(directory_path, dispatcher);
 }
 
+bool PepperPluginDelegateImpl::QueryAvailableSpace(
+    const GURL& origin, quota::StorageType type,
+    AvailableSpaceCallback* callback) {
+  ChildThread::current()->quota_dispatcher()->QueryStorageUsageAndQuota(
+      origin, type, new QuotaCallbackTranslator(callback));
+  return true;
+}
+
+void PepperPluginDelegateImpl::NotifyStorageModified(
+    quota::QuotaClient::ID client_id, const GURL& origin,
+    quota::StorageType type, int64 delta) {
+  ChildThread::current()->quota_dispatcher()->NotifyStorageModified(
+      client_id, origin, type, delta);
+}
+
 class AsyncOpenFileSystemURLCallbackTranslator
     : public fileapi::FileSystemCallbackDispatcher {
  public:
   AsyncOpenFileSystemURLCallbackTranslator(
       webkit::ppapi::PluginDelegate::AsyncOpenFileCallback* callback)
     : callback_(callback) {
   }
 
   virtual ~AsyncOpenFileSystemURLCallbackTranslator() {}
 
@@ skipping 10 matching lines @@
       bool has_more) {
     NOTREACHED();
   }
   virtual void DidOpenFileSystem(const std::string& name,
                                  const GURL& root) {
     NOTREACHED();
   }
 
   virtual void DidFail(base::PlatformFileError error_code) {
     base::PlatformFile invalid_file = base::kInvalidPlatformFileValue;
-    callback_->Run(error_code, base::PassPlatformFile(&invalid_file));
+    callback_->Run(error_code, base::PassPlatformFile(&invalid_file), -1);
   }
 
   virtual void DidWrite(int64 bytes, bool complete) {
     NOTREACHED();
   }
 
   virtual void DidOpenFile(
       base::PlatformFile file,
-      base::ProcessHandle unused) {
-    callback_->Run(base::PLATFORM_FILE_OK, base::PassPlatformFile(&file));
+      base::ProcessHandle unused,
+      int64 file_size) {
+    callback_->Run(base::PLATFORM_FILE_OK, base::PassPlatformFile(&file),
+                   file_size);
     // Make sure we won't leak file handle if the requester has died.
     if (file != base::kInvalidPlatformFileValue) {
       base::FileUtilProxy::Close(
           RenderThread::current()->GetFileThreadMessageLoopProxy(), file, NULL);
     }
   }
 
-private:  // TODO(ericu): Delete this?
-  webkit::ppapi::PluginDelegate::AsyncOpenFileCallback* callback_;
+private:
+  scoped_ptr<webkit::ppapi::PluginDelegate::AsyncOpenFileCallback> callback_;
 };
 
 bool PepperPluginDelegateImpl::AsyncOpenFileSystemURL(
     const GURL& path, int flags, AsyncOpenFileCallback* callback) {
 
   FileSystemDispatcher* file_system_dispatcher =
       ChildThread::current()->file_system_dispatcher();
   return file_system_dispatcher->OpenFile(path, flags,
       new AsyncOpenFileSystemURLCallbackTranslator(callback));
 }
@@ skipping 282 matching lines @@
   if (!base::SharedMemory::IsHandleValid(handle)) {
     DLOG(WARNING) << "Browser failed to allocate shared memory";
     return NULL;
   }
   return new base::SharedMemory(handle, false);
 }
 
 ppapi::Preferences PepperPluginDelegateImpl::GetPreferences() {
   return ppapi::Preferences(render_view_->webkit_preferences());
 }