Introduce intercepting and handling devtools messages in the renderer.

content/browser/devtools/render_view_devtools_agent_host.cc

 // Copyright (c) 2012 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/render_view_devtools_agent_host.h"
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/lazy_instance.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/devtools/devtools_manager_impl.h"
+#include "content/browser/devtools/devtools_protocol.h"
 #include "content/browser/devtools/render_view_devtools_agent_host.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/devtools_messages.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/javascript_dialog_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
@@ skipping 41 matching lines @@
     agent_host_->RenderViewHostDestroyed(rvh);
   }
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
     return agent_host_->OnRvhMessageReceived(message);
   }
  private:
   RenderViewDevToolsAgentHost* agent_host_;
   DISALLOW_COPY_AND_ASSIGN(DevToolsAgentHostRvhObserver);
 };
 
+class RendererOverridesHandler : public DevToolsProtocol::Handler {

[pfeldman, 2013/02/13 17:38:24]

Since we expect it to grow, I would immediately define it in its own file.

[kkania, 2013/02/13 19:17:19]

Done.

+ public:
+  explicit RendererOverridesHandler(
+      const DevToolsProtocol::Notifier& notifier,
+      DevToolsAgentHost* agent)
+      : DevToolsProtocol::Handler(notifier),
+        agent_(agent) {
+    RegisterCommandHandler(
+        "DOM.setFileInputFiles",

[pfeldman, 2013/02/13 17:38:24]

You would then be able to declare constants for the method and attribute names.

[kkania, 2013/02/13 19:17:19]

I don't see the benefit of declaring a constant if it is only used in one place,
unless it clarifies usage (e.g., kStackSize would be better than a plain 4096).
Made 'files' a constant since it is used in two places.

+        base::Bind(
+            &RendererOverridesHandler::GrantPermissionsForSetFileInputFiles,
+            base::Unretained(this)));
+  }
+  virtual ~RendererOverridesHandler() {}
+
+ private:
+  scoped_ptr<DevToolsProtocol::Response> GrantPermissionsForSetFileInputFiles(
+      DevToolsProtocol::Command* command) {
+    const base::ListValue* file_list;
+    if (!command->params()->GetList("files", &file_list)) {
+      return command->ErrorResponse(
+          DevToolsProtocol::kErrorInvalidParams,
+          "Missing or invalid 'files' parameter");
+    }
+    for (size_t i = 0; i < file_list->GetSize(); ++i) {
+      base::FilePath::StringType file;
+      if (!file_list->GetString(i, &file)) {
+        return command->ErrorResponse(
+            DevToolsProtocol::kErrorInvalidParams,
+            "'files' must be a list of strings");
+      }
+      ChildProcessSecurityPolicyImpl::GetInstance()->GrantReadFile(
+          agent_->GetRenderViewHost()->GetProcess()->GetID(),
+          base::FilePath(file));
+    }
+    return scoped_ptr<DevToolsProtocol::Response>();
+  }
+
+  DevToolsAgentHost* agent_;
+};
+
 // static
 scoped_refptr<DevToolsAgentHost>
 DevToolsAgentHost::GetFor(RenderViewHost* rvh) {
   RenderViewDevToolsAgentHost* result = FindAgentHost(rvh);
   if (!result)
     result = new RenderViewDevToolsAgentHost(rvh);
   return result;
 }
 
 // static
@@ skipping 51 matching lines @@
     DevToolsAgentHost::ConnectRenderViewHost(cookie, current);
 }
 
 RenderViewDevToolsAgentHost::RenderViewDevToolsAgentHost(
     RenderViewHost* rvh) {
   ConnectRenderViewHost(rvh, false);
   g_instances.Get().push_back(this);
   RenderViewHostDelegate* delegate = render_view_host_->GetDelegate();
   if (delegate && delegate->GetAsWebContents())
     Observe(delegate->GetAsWebContents());
+  overrides_handler_.reset(new RendererOverridesHandler(

[pfeldman, 2013/02/13 17:38:24]

That's the one I was talking about: it does not really need notifier.

[kkania, 2013/02/13 19:17:19]

Done.

+      base::Bind(&RenderViewDevToolsAgentHost::OnDispatchOnInspectorFrontend,
+                 base::Unretained(this)),
+      this));
 }
 
 RenderViewHost* RenderViewDevToolsAgentHost::GetRenderViewHost() {
   return render_view_host_;
 }
 
 void RenderViewDevToolsAgentHost::DispatchOnInspectorBackend(
     const std::string& message) {
-  DevToolsAgentHostImpl::DispatchOnInspectorBackend(message);
+  std::string error_message;
+  scoped_ptr<DevToolsProtocol::Command> command(
+      DevToolsProtocol::ParseCommand(message, &error_message));
+  if (!command) {
+    OnDispatchOnInspectorFrontend(error_message);
+    return;
+  }
+
+  scoped_ptr<DevToolsProtocol::Response> overridden_response(
+      overrides_handler_->HandleCommand(command.get()));
+  if (overridden_response)
+    OnDispatchOnInspectorFrontend(overridden_response->Serialize());
+  else
+    DevToolsAgentHostImpl::DispatchOnInspectorBackend(message);
 }
 
 void RenderViewDevToolsAgentHost::SendMessageToAgent(IPC::Message* msg) {
   msg->set_routing_id(render_view_host_->GetRoutingID());
   render_view_host_->Send(msg);
 }
 
 void RenderViewDevToolsAgentHost::NotifyClientAttaching() {
   if (!render_view_host_)
     return;
@@ skipping 189 matching lines @@
     JavaScriptDialogManager* manager =
         web_contents->GetDelegate()->GetJavaScriptDialogManager();
     if (!manager)
       return false;
     return manager->HandleJavaScriptDialog(web_contents, accept);
   }
   return false;
 }
 
 }  // namespace content