Backend for DevTools quota managements.

content/browser/devtools/renderer_overrides_handler.cc

 // Copyright (c) 2013 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/browser/devtools/renderer_overrides_handler.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string16.h"
 #include "base/values.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/devtools/devtools_protocol_constants.h"
 #include "content/browser/devtools/devtools_tracing_handler.h"
 #include "content/browser/renderer_host/dip_util.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/common/view_messages.h"
 #include "content/port/browser/render_widget_host_view_port.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/javascript_dialog_manager.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
+#include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/page_transition_types.h"
 #include "content/public/common/referrer.h"
 #include "ipc/ipc_sender.h"
+#include "net/base/net_util.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/snapshot/snapshot.h"
 #include "url/gurl.h"
+#include "webkit/browser/quota/quota_manager.h"
 
 using WebKit::WebGestureEvent;
 using WebKit::WebInputEvent;
 using WebKit::WebMouseEvent;
 
 namespace content {
 
 namespace {
 
 static const char kPng[] = "png";
@@ skipping 53 matching lines @@
       devtools::Page::startScreencast::kName,
       base::Bind(
           &RendererOverridesHandler::PageStartScreencast,
           base::Unretained(this)));
   RegisterCommandHandler(
       devtools::Page::stopScreencast::kName,
       base::Bind(
           &RendererOverridesHandler::PageStopScreencast,
           base::Unretained(this)));
   RegisterCommandHandler(
+      devtools::Quota::queryUsageAndQuota::kName,
+      base::Bind(
+          &RendererOverridesHandler::QuotaQueryUsageAndQuota,
+          base::Unretained(this)));
+  RegisterCommandHandler(
       devtools::Input::dispatchMouseEvent::kName,
       base::Bind(
           &RendererOverridesHandler::InputDispatchMouseEvent,
           base::Unretained(this)));
   RegisterCommandHandler(
       devtools::Input::dispatchGestureEvent::kName,
       base::Bind(
           &RendererOverridesHandler::InputDispatchGestureEvent,
           base::Unretained(this)));
 }
@@ skipping 315 matching lines @@
     response->Set(devtools::Page::kParamViewport, viewport);
   }
 
   if (command) {
     SendAsyncResponse(command->SuccessResponse(response));
   } else {
     SendNotification(devtools::Page::screencastFrame::kName, response);
   }
 }
 
+namespace {
+
+typedef base::Callback<void (DevToolsProtocol::Response*)> RespondCallback;
+
+class QuotaTask {
+ public:
+  virtual ~QuotaTask() {}
+
+  static void Run(scoped_ptr<QuotaTask> task) {
+    // Will be deleted when done.
+    BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&QuotaTask::Start, base::Unretained(task.release())));
+  }
+
+ protected:
+  QuotaTask(scoped_refptr<DevToolsProtocol::Command> command,
+      const RespondCallback& callback,
+      RenderViewHost* render_vew_host,
+      const std::string& security_origin)
+      : command_(command),
+        callback_(callback),
+        host_(net::GetHostOrSpecFromURL(GURL(security_origin))),
+        quota_manager_(render_vew_host->GetProcess()->
+            GetStoragePartition()->GetQuotaManager()),
+        response_loop_proxy_(base::MessageLoopProxy::current()) {
+
+  }
+
+  // Called on IO thread.
+  virtual void Start() = 0;
+
+  void Done(scoped_ptr<base::DictionaryValue> responseData) {

[Vladislav Kaznacheev, 2013/09/05 12:46:10]

Why are these methods public? They are only used by the derived class.

[SeRya, 2013/09/05 13:10:46]

It is protected, not public (see line before the constrictor).

+    base::MessageLoopProxy* loop = response_loop_proxy_.get();
+    loop->PostTask(FROM_HERE, base::Bind(
+        &QuotaTask::RespondOnCallerThreadAndDelete,
+        this, base::Passed(&responseData)));
+  }
+
+  scoped_refptr<quota::QuotaManager> GetQuotaManager() {
+    return quota_manager_.get();
+  }
+
+  const std::string& host() const { return host_; }
+
+ private:
+  scoped_refptr<DevToolsProtocol::Command> command_;
+  RespondCallback callback_;
+
+  std::string host_;
+  scoped_refptr<quota::QuotaManager> quota_manager_;
+
+  scoped_refptr<base::MessageLoopProxy> response_loop_proxy_;
+
+  void RespondOnCallerThread(scoped_ptr<base::DictionaryValue> response) {
+    callback_.Run(command_->SuccessResponse(response.release()).get());
+  }
+
+  static void RespondOnCallerThreadAndDelete(QuotaTask* task,
+      scoped_ptr<base::DictionaryValue> responseData) {
+    task->RespondOnCallerThread(responseData.Pass());
+    delete task;
+  }
+};
+
+class GetUsageAndQuotaTask : public QuotaTask {
+ public:
+  GetUsageAndQuotaTask(scoped_refptr<DevToolsProtocol::Command> command,
+      const RespondCallback& callback,
+      RenderViewHost* render_vew_host,
+      const std::string& security_origin)
+      : QuotaTask(command, callback, render_vew_host, security_origin),
+      quota_(new base::DictionaryValue),
+      usage_(new base::DictionaryValue) {
+    steps_.push_back(base::Bind(&quota::QuotaManager::GetAvailableSpace,
+        GetQuotaManager(),
+        MakeQuotaCallback("availableSpace")));
+
+    steps_.push_back(base::Bind(&quota::QuotaManager::GetTemporaryGlobalQuota,
+        GetQuotaManager(),
+        MakeQuotaCallback("temporaryGlobalQuota")));
+
+    steps_.push_back(base::Bind(&quota::QuotaManager::GetPersistentHostQuota,
+        GetQuotaManager(),
+        host(),
+        MakeQuotaCallback("persistentHostQuota")));
+
+    steps_.push_back(base::Bind(&GetUsageAndQuotaTask::GetHostUsage,
+        base::Unretained(this),
+        quota::kStorageTypeTemporary,
+        quota::QuotaClient::kFileSystem,
+        "temporaryFileSystemUsage"));
+
+    steps_.push_back(base::Bind(&GetUsageAndQuotaTask::GetHostUsage,
+        base::Unretained(this),
+        quota::kStorageTypePersistent,
+        quota::QuotaClient::kFileSystem,
+        "persistentFileSystemUsage"));
+
+    steps_.push_back(base::Bind(&GetUsageAndQuotaTask::GetHostUsage,
+        base::Unretained(this),
+        quota::kStorageTypeSyncable,
+        quota::QuotaClient::kFileSystem,
+        "syncableFileSystemUsage"));
+
+    steps_.push_back(base::Bind(&GetUsageAndQuotaTask::GetHostUsage,
+        base::Unretained(this),
+        quota::kStorageTypeTemporary,
+        quota::QuotaClient::kDatabase,
+        "databaseUsage"));
+
+    steps_.push_back(base::Bind(&GetUsageAndQuotaTask::GetHostUsage,
+        base::Unretained(this),
+        quota::kStorageTypeTemporary,
+        quota::QuotaClient::kAppcache,
+        "appcacheUsage"));
+
+    steps_.push_back(base::Bind(&GetUsageAndQuotaTask::GetHostUsage,
+        base::Unretained(this),
+        quota::kStorageTypeTemporary,
+        quota::QuotaClient::kIndexedDatabase,
+        "indexedDatabaseUsage"));
+
+    steps_.push_back(base::Bind(&GetUsageAndQuotaTask::Finish,
+        base::Unretained(this)));
+  }
+
+ protected:
+  virtual void Start() OVERRIDE {
+    currentStep_ = 0;
+    readyForNextStep_ = true;
+    stepDone_ = true;
+    DoStep();
+  }
+
+ private:
+  scoped_ptr<base::DictionaryValue> quota_;
+  scoped_ptr<base::DictionaryValue> usage_;
+  std::vector<base::Callback<void (void)> > steps_;
+  bool readyForNextStep_;
+  bool stepDone_;
+  int currentStep_;
+
+  void GetHostUsage(quota::StorageType type,
+                    quota::QuotaClient::ID client_id,
+                    const char* name) {
+    quota::UsageCallback callback =
+        base::Bind(&GetUsageAndQuotaTask::DidGetUsage,
+            base::Unretained(this), name);
+    GetQuotaManager()->GetHostUsage(host(), type, client_id, callback);
+  }
+
+  void Finish() {
+    scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue);
+    result->Set("quota", quota_.release());
+    result->Set("usage", usage_.release());
+    Done(result.Pass());
+  }
+
+  void DoStep() {
+    DCHECK(readyForNextStep_);
+    DCHECK(stepDone_);
+    readyForNextStep_ = false;
+    stepDone_ = false;
+    int startStep = currentStep_;
+
+    steps_[currentStep_].Run();
+
+    readyForNextStep_ = true;
+    if (stepDone_) {
+      DCHECK(currentStep_ == startStep + 1);
+      DoStep();
+    }
+  }
+
+  void StepDone() {
+    DCHECK(!stepDone_);
+    currentStep_++;
+    stepDone_ = true;
+    if (readyForNextStep_)
+      DoStep();
+  }
+
+  void DidGetQuota(const char* name,
+      quota::QuotaStatusCode status,
+      int64 space) {
+    if (status == quota::kQuotaStatusOk)
+      quota_->SetDouble(name, space);
+    StepDone();
+  }
+
+  quota::QuotaCallback MakeQuotaCallback(const char* name) {
+    return base::Bind(&GetUsageAndQuotaTask::DidGetQuota,
+        base::Unretained(this), name);
+  }
+
+  void DidGetUsage(const char* name, int64 usage_value) {
+    usage_->SetDouble(name, usage_value);
+    StepDone();
+  }
+};
+
+}  // namespace
+
+scoped_refptr<DevToolsProtocol::Response>
+RendererOverridesHandler::QuotaQueryUsageAndQuota(
+    scoped_refptr<DevToolsProtocol::Command> command) {
+  base::DictionaryValue* params = command->params();
+  std::string security_origin;
+  if (!params || !params->GetString(
+      devtools::Quota::queryUsageAndQuota::kParamSecurityOrigin,
+      &security_origin)) {
+    return command->InvalidParamResponse(
+        devtools::Quota::queryUsageAndQuota::kParamSecurityOrigin);
+  }
+
+  RespondCallback callback = base::Bind(
+      &RendererOverridesHandler::AsyncTaskDone, weak_factory_.GetWeakPtr());
+  QuotaTask::Run(scoped_ptr<QuotaTask>(new GetUsageAndQuotaTask(command,
+      callback, agent_->GetRenderViewHost(), security_origin)));
+  return command->AsyncResponsePromise();
+}
+
+void RendererOverridesHandler::AsyncTaskDone(
+    DevToolsProtocol::Response* response) {
+  SendRawMessage(response->Serialize());
+}
 
 // Input agent handlers  ------------------------------------------------------
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::InputDispatchMouseEvent(
     scoped_refptr<DevToolsProtocol::Command> command) {
   base::DictionaryValue* params = command->params();
   if (!params)
     return NULL;
 
@@ skipping 126 matching lines @@
       return NULL;
     }
     event.data.pinchUpdate.scale = static_cast<float>(scale);
   }
 
   host->ForwardGestureEvent(event);
   return command->SuccessResponse(NULL);
 }
 
 }  // namespace content