Intercept Inspector DOM.setFileInputFiles and grant read permissions to the

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 "base/values.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/devtools/devtools_manager_impl.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"
@@ skipping 120 matching lines @@
   g_instances.Get().push_back(this);
   RenderViewHostDelegate* delegate = render_view_host_->GetDelegate();
   if (delegate && delegate->GetAsWebContents())
     Observe(delegate->GetAsWebContents());
 }
 
 RenderViewHost* RenderViewDevToolsAgentHost::GetRenderViewHost() {
   return render_view_host_;
 }
 
+void RenderViewDevToolsAgentHost::DispatchOnInspectorBackend(
+    const std::string& message) {
+  std::string error;
+  scoped_ptr<DevToolsProtocol::Command> command(
+      DevToolsProtocol::ParseCommand(message, &error));
+  if (!command) {
+    OnDispatchOnInspectorFrontend(error);
+    return;
+  }
+
+  scoped_ptr<DevToolsProtocol::Response> early_response;
+  if (command->method() == "DOM.setFileInputFiles")

[pfeldman, 2013/02/12 15:03:27]

I think we could reuse DomainHandler from DevToolsBrowserTarget
(devtools_browser_target.h). It has a nice 

virtual scoped_ptr<DevToolsProtocol::Response> HandleCommand(
        DevToolsProtocol::Command* command);

interface that you could call into.

Take a look at how devtools_tracing_handler is extending it and registers its
handlers using DomainHandler::RegisterCommandHandler (it should have been
protected).

Here is what I would do:
1) Land this change with renames and empty DispatchOnInspectorBackend
2) Move DevToolsBrowserTarget::DomainHandler into DevToolsProtocol::Handler
(beside Command, Response and Notification)
3) Create a new RendererOverridesHandler : public DevToolsProtocol::Handler,
call into it from here. If it returns early response, use it, fall back to
standard path otherwise.
4) Put all overrides into that new RendererOverridesHandler

+    early_response = GrantSetFileInputFilesPermissions(*command);
+
+  if (early_response)
+    OnDispatchOnInspectorFrontend(early_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;
 
   ChildProcessSecurityPolicyImpl::GetInstance()->GrantReadRawCookies(
@@ skipping 186 matching lines @@
   if (web_contents) {
     JavaScriptDialogManager* manager =
         web_contents->GetDelegate()->GetJavaScriptDialogManager();
     if (!manager)
       return false;
     return manager->HandleJavaScriptDialog(web_contents, accept);
   }
   return false;
 }
 
+scoped_ptr<DevToolsProtocol::Response>
+RenderViewDevToolsAgentHost::GrantSetFileInputFilesPermissions(
+    const 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(
+        render_view_host_->GetProcess()->GetID(), base::FilePath(file));
+  }
+  return scoped_ptr<DevToolsProtocol::Response>();
+}
+
 }  // namespace content