DevTools: Implement raw cookies access for inspector.

chrome/browser/debugger/devtools_manager.cc

 // Copyright (c) 2009 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 "chrome/browser/debugger/devtools_manager.h"
 
 #include "base/message_loop.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browsing_instance.h"
+#include "chrome/browser/child_process_security_policy.h"
 #include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/debugger/devtools_client_host.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/site_instance.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/devtools_messages.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "googleurl/src/gurl.h"
@@ skipping 15 matching lines @@
 
 DevToolsManager::~DevToolsManager() {
   DCHECK(inspected_rvh_to_client_host_.empty());
   DCHECK(client_host_to_inspected_rvh_.empty());
 }
 
 DevToolsClientHost* DevToolsManager::GetDevToolsClientHostFor(
     RenderViewHost* inspected_rvh) {
   InspectedRvhToClientHostMap::iterator it =
       inspected_rvh_to_client_host_.find(inspected_rvh);
-  if (it != inspected_rvh_to_client_host_.end()) {
+  if (it != inspected_rvh_to_client_host_.end())
     return it->second;
-  }
   return NULL;
 }
 
 void DevToolsManager::RegisterDevToolsClientHostFor(
     RenderViewHost* inspected_rvh,
     DevToolsClientHost* client_host) {
   DCHECK(!GetDevToolsClientHostFor(inspected_rvh));
 
   inspected_rvh_to_client_host_[inspected_rvh] = client_host;
   client_host_to_inspected_rvh_[client_host] = inspected_rvh;
   client_host->set_close_listener(this);
 
   SendAttachToAgent(inspected_rvh);
 }
 
 void DevToolsManager::ForwardToDevToolsAgent(
     RenderViewHost* client_rvh,
     const IPC::Message& message) {
   DevToolsClientHost* client_host = FindOnwerDevToolsClientHost(client_rvh);
-  if (client_host) {
+  if (client_host)
     ForwardToDevToolsAgent(client_host, message);
-  }
 }
 
 void DevToolsManager::ForwardToDevToolsAgent(DevToolsClientHost* from,
                                              const IPC::Message& message) {
   RenderViewHost* inspected_rvh = GetInspectedRenderViewHost(from);
   if (!inspected_rvh) {
     // TODO(yurys): notify client that the agent is no longer available
     NOTREACHED();
     return;
   }
 
   IPC::Message* m = new IPC::Message(message);
   m->set_routing_id(inspected_rvh->routing_id());
   inspected_rvh->Send(m);
 }
 
 void DevToolsManager::ForwardToDevToolsClient(RenderViewHost* inspected_rvh,
                                               const IPC::Message& message) {
   DevToolsClientHost* client_host = GetDevToolsClientHostFor(inspected_rvh);
   if (!client_host) {
     // Client window was closed while there were messages
     // being sent to it.
     return;
   }
   client_host->SendMessageToClient(message);
 }
 
 void DevToolsManager::ActivateWindow(RenderViewHost* client_rvh) {
   DevToolsClientHost* client_host = FindOnwerDevToolsClientHost(client_rvh);
-  if (!client_host) {
+  if (!client_host)
     return;
-  }
+
   DevToolsWindow* window = client_host->AsDevToolsWindow();
   DCHECK(window);
   window->Activate();
 }
 
 void DevToolsManager::CloseWindow(RenderViewHost* client_rvh) {
   DevToolsClientHost* client_host = FindOnwerDevToolsClientHost(client_rvh);
-  if (client_host) {
+  if (client_host)
     CloseWindow(client_host);
-  }
 }
 
 void DevToolsManager::DockWindow(RenderViewHost* client_rvh) {
   ReopenWindow(client_rvh, true);
 }
 
 void DevToolsManager::UndockWindow(RenderViewHost* client_rvh) {
   ReopenWindow(client_rvh, false);
 }
 
@@ skipping 18 matching lines @@
                                      int x,
                                      int y) {
   OpenDevToolsWindow(inspected_rvh);
   IPC::Message* m = new DevToolsAgentMsg_InspectElement(x, y);
   m->set_routing_id(inspected_rvh->routing_id());
   inspected_rvh->Send(m);
 }
 
 void DevToolsManager::ClientHostClosing(DevToolsClientHost* host) {
   RenderViewHost* inspected_rvh = GetInspectedRenderViewHost(host);
-  if (!inspected_rvh) {
+  if (!inspected_rvh)
     return;
-  }
   SendDetachToAgent(inspected_rvh);
 
   inspected_rvh_to_client_host_.erase(inspected_rvh);
   client_host_to_inspected_rvh_.erase(host);
 }
 
 RenderViewHost* DevToolsManager::GetInspectedRenderViewHost(
     DevToolsClientHost* client_host) {
   ClientHostToInspectedRvhMap::iterator it =
       client_host_to_inspected_rvh_.find(client_host);
-  if (it != client_host_to_inspected_rvh_.end()) {
+  if (it != client_host_to_inspected_rvh_.end())
     return it->second;
-  }
   return NULL;
 }
 
 void DevToolsManager::UnregisterDevToolsClientHostFor(
       RenderViewHost* inspected_rvh) {
   DevToolsClientHost* host = GetDevToolsClientHostFor(inspected_rvh);
-  if (!host) {
+  if (!host)
     return;
-  }
   inspected_rvh_to_client_host_.erase(inspected_rvh);
   client_host_to_inspected_rvh_.erase(host);
-  if (inspected_rvh_for_reopen_ == inspected_rvh) {
+  if (inspected_rvh_for_reopen_ == inspected_rvh)
     inspected_rvh_for_reopen_ = NULL;
-  }
 
   // Issue tab closing event post unbound.
   host->InspectedTabClosing();
+
+  int process_id = inspected_rvh->process()->id();
+  for (InspectedRvhToClientHostMap::iterator it =
+           inspected_rvh_to_client_host_.begin();
+       it != inspected_rvh_to_client_host_.end();
+       ++it) {
+    if (it->first->process()->id() == process_id)
+      return;
+  }
+  // We've disconnected from the last renderer -> revoke cookie permissions.
+  ChildProcessSecurityPolicy::GetInstance()->RevokeReadRawCookies(process_id);
 }
 
 void DevToolsManager::OnNavigatingToPendingEntry(RenderViewHost* rvh,
                                                  RenderViewHost* dest_rvh,
                                                  const GURL& gurl) {
   if (in_initial_show_) {
     // Mute this even in case it is caused by the initial show routines.
     return;
   }
   DevToolsClientHost* client_host =
@@ skipping 19 matching lines @@
       MessageLoop::current()->PostTask(FROM_HERE,
           NewRunnableMethod(this,
                             &DevToolsManager::ForceReopenWindow));
       return;
     }
   }
 }
 
 void DevToolsManager::SendAttachToAgent(RenderViewHost* inspected_rvh) {
   if (inspected_rvh) {
+    ChildProcessSecurityPolicy::GetInstance()->GrantReadRawCookies(
+        inspected_rvh->process()->id());
     IPC::Message* m = new DevToolsAgentMsg_Attach();
     m->set_routing_id(inspected_rvh->routing_id());
     inspected_rvh->Send(m);
   }
 }
 
 void DevToolsManager::SendDetachToAgent(RenderViewHost* inspected_rvh) {
   if (inspected_rvh) {
     IPC::Message* m = new DevToolsAgentMsg_Detach();
     m->set_routing_id(inspected_rvh->routing_id());
@@ skipping 10 matching lines @@
   }
 }
 
 DevToolsClientHost* DevToolsManager::FindOnwerDevToolsClientHost(
     RenderViewHost* client_rvh) {
   for (InspectedRvhToClientHostMap::iterator it =
            inspected_rvh_to_client_host_.begin();
        it != inspected_rvh_to_client_host_.end();
        ++it) {
     DevToolsWindow* win = it->second->AsDevToolsWindow();
-    if (!win) {
+    if (!win)
       continue;
-    }
-    if (client_rvh == win->GetRenderViewHost()) {
+    if (client_rvh == win->GetRenderViewHost())
       return it->second;
-    }
   }
   return NULL;
 }
 
 void DevToolsManager::ReopenWindow(RenderViewHost* client_rvh, bool docked) {
   DevToolsClientHost* client_host = FindOnwerDevToolsClientHost(client_rvh);
-  if (!client_host) {
+  if (!client_host)
     return;
-  }
   RenderViewHost* inspected_rvh = GetInspectedRenderViewHost(client_host);
   DCHECK(inspected_rvh);
   inspected_rvh->process()->profile()->GetPrefs()->SetBoolean(
       prefs::kDevToolsOpenDocked, docked);
 
   DevToolsWindow* window = client_host->AsDevToolsWindow();
   DCHECK(window);
   window->SetDocked(docked);
 }
 
@@ skipping 10 matching lines @@
         GetBoolean(prefs::kDevToolsOpenDocked);
 #endif
     host = new DevToolsWindow(
         inspected_rvh->site_instance()->browsing_instance()->profile(),
         inspected_rvh,
         docked);
     RegisterDevToolsClientHostFor(inspected_rvh, host);
     do_open = true;
   }
   DevToolsWindow* window = host->AsDevToolsWindow();
-  if (!window) {
+  if (!window)
     return;
-  }
 
   // If window is docked and visible, we hide it on toggle. If window is
   // undocked, we show (activate) it.
   if (!window->is_docked() || do_open) {
     in_initial_show_ = true;
     window->Show();
     in_initial_show_ = false;
   } else {
     CloseWindow(host);
   }
 }
 
 void DevToolsManager::CloseWindow(DevToolsClientHost* client_host) {
   RenderViewHost* inspected_rvh = GetInspectedRenderViewHost(client_host);
   DCHECK(inspected_rvh);
   SendDetachToAgent(inspected_rvh);
 
   UnregisterDevToolsClientHostFor(inspected_rvh);
 }