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/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 "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 75 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)));
 }
 
 RendererOverridesHandler::~RendererOverridesHandler() {}
 
 void RendererOverridesHandler::OnClientDetached() {
   screencast_command_ = NULL;
@@ skipping 236 matching lines @@
     response->SetString(
         devtools::Page::captureScreenshot::kResponseData, base_64_data);
     SendAsyncResponse(command->SuccessResponse(response));
   } else {
     response->SetString(
         devtools::Page::screencastFrame::kResponseData, base_64_data);
     SendNotification(devtools::Page::screencastFrame::kName, response);
   }
 }
 
+namespace {

[Vladislav Kaznacheev, 2013/08/28 10:46:14]

This namespace is 200 lines of very task-specific and non-trivial code. I
suggest extracting it into a separate file.

[SeRya, 2013/08/29 14:24:16]

Only 60 likes are quite generic (QuotaTask), 120 lines is about single
DevToolsProtocol message. And even that 60 lines not such generic to be useful
outside of this file. I think this file is a good place for this code.

+
+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()) {

[Vladislav Kaznacheev, 2013/08/28 10:46:14]

Looks a bit over-engineered. I assume that the caller is running on some
well-known thread (UI?), why not use it?

[SeRya, 2013/08/29 14:24:16]

I'm a bit hesitate to introduce first thread dependency in the file. We don't
have unit tests for this code but if we would it makes testing herder. And by
the way quota::QuotaTask uses the same approach (likely because QuotaManager
does have unit tests. It worth only 2 additional lines of code (declaration and
initialization response_loop_proxy_).

+
+  }
+
+  // Called on IO thread.
+  virtual void Start() = 0;
+
+  void Done(scoped_ptr<base::DictionaryValue> responseData) {
+    base::MessageLoopProxy* loop = response_loop_proxy_.get();
+    loop->PostTask(FROM_HERE, base::Bind(
+        &QuotaTask::ResponseOnCallerThreadAndDelete,
+        this, base::Passed(&responseData)));
+  }
+
+  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 ResponseOnCallerThread(scoped_ptr<base::DictionaryValue> response) {

[Vladislav Kaznacheev, 2013/08/28 10:46:14]

RespondOnCallerThread is better English

[SeRya, 2013/08/29 14:24:16]

Done.

+    callback_.Run(command_->SuccessResponse(response.release()).get());
+  }
+
+  static void ResponseOnCallerThreadAndDelete(QuotaTask* task,

[Vladislav Kaznacheev, 2013/08/28 10:46:14]

RespondOnCallerThreadAndDelete is better English

[SeRya, 2013/08/29 14:24:16]

Done.

+      scoped_ptr<base::DictionaryValue> responseData) {
+    task->ResponseOnCallerThread(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) {
+  }
+
+ protected:
+  virtual void Start() OVERRIDE {
+    step_ = 0;
+    readyToNextStep_ = true;

[Vladislav Kaznacheev, 2013/08/28 10:46:14]

readyForNextStep

[SeRya, 2013/08/29 14:24:16]

Done.

+    stepDone_ = true;
+    DoStep();
+  }
+
+ private:
+  scoped_ptr<base::DictionaryValue> quota_;
+  scoped_ptr<base::DictionaryValue> usage_;
+  bool readyToNextStep_;
+  bool stepDone_;
+  int step_;
+
+  void DoStep() {
+    DCHECK(readyToNextStep_);
+    DCHECK(stepDone_);
+    readyToNextStep_ = false;
+    stepDone_ = false;
+    int startStep = step_;
+
+    switch (step_) {

[Vladislav Kaznacheev, 2013/08/28 10:46:14]

This switch makes me sad. Please consider replacing it with an array of
callbacks.

[SeRya, 2013/08/29 14:24:16]

Done.

+      case 0:
+        GetQuotaManager()->GetAvailableSpace(
+            MakeQuotaCallback("availableSpace"));
+        break;
+
+      case 1:
+        GetQuotaManager()->GetTemporaryGlobalQuota(
+            MakeQuotaCallback("temporaryGlobalQuota"));
+        break;
+
+      case 2:
+        GetQuotaManager()->GetPersistentHostQuota(host(),
+            MakeQuotaCallback("persistentHostQuota"));
+        break;
+
+      case 3:
+        GetQuotaManager()->GetHostUsage(host(),
+            quota::kStorageTypeTemporary,
+            quota::QuotaClient::kFileSystem,
+            MakeUsageCallback("temporaryFileSystemUsage"));
+        break;
+
+      case 4:
+        GetQuotaManager()->GetHostUsage(host(),
+            quota::kStorageTypePersistent,
+            quota::QuotaClient::kFileSystem,
+            MakeUsageCallback("persistentFileSystemUsage"));
+        break;
+
+      case 5:
+        GetQuotaManager()->GetHostUsage(host(),
+            quota::kStorageTypeSyncable,
+            quota::QuotaClient::kFileSystem,
+            MakeUsageCallback("syncableFileSystemUsage"));
+        break;
+
+      case 6:
+        GetQuotaManager()->GetHostUsage(host(),
+            quota::kStorageTypeTemporary,
+            quota::QuotaClient::kDatabase,
+            MakeUsageCallback("databaseUsage"));
+        break;
+
+      case 7:
+        GetQuotaManager()->GetHostUsage(host(),
+            quota::kStorageTypeTemporary,
+            quota::QuotaClient::kAppcache,
+            MakeUsageCallback("appcacheUsage"));
+        break;
+
+      case 8:
+        GetQuotaManager()->GetHostUsage(host(),
+            quota::kStorageTypeTemporary,
+            quota::QuotaClient::kIndexedDatabase,
+            MakeUsageCallback("indexedDatabaseUsage"));
+        break;
+
+      case 9: {
+          scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue);
+          result->Set("quota", quota_.release());
+          result->Set("usage", usage_.release());
+          Done(result.Pass());
+        }
+    }
+
+    readyToNextStep_ = true;
+    if (stepDone_) {
+      DCHECK(step_ == startStep + 1);
+      DoStep();
+    }
+  }
+
+  void StepDone() {
+    DCHECK(!stepDone_);
+    step_++;
+    stepDone_ = true;
+    if (readyToNextStep_)
+      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();
+  }
+
+  quota::UsageCallback MakeUsageCallback(const char* name) {
+    return base::Bind(&GetUsageAndQuotaTask::DidGetUsage,
+        base::Unretained(this), name);
+  }
+};
+
+}  // 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, base::Unretained(this));

[Vladislav Kaznacheev, 2013/08/28 10:46:14]

base::Unretained allows this to be deleted before QuotaTask uses the callback. I
suggest using weak pointer (see weak_factory_ usages in this file).

[SeRya, 2013/08/29 14:24:16]

Good catch. Thanks.

+  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 62 matching lines @@
   } else {
     return NULL;
   }
 
   host->ForwardMouseEvent(mouse_event);
 
   return command->SuccessResponse(NULL);
 }
 
 }  // namespace content