DevTools: migrate DevTools APIs to use WebContents instead of RenderViewHost.

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 <map>
 #include <string>
 
 #include "base/barrier_closure.h"
@@ skipping 133 matching lines @@
   RegisterCommandHandler(
       devtools::Input::emulateTouchFromMouseEvent::kName,
       base::Bind(
           &RendererOverridesHandler::InputEmulateTouchFromMouseEvent,
           base::Unretained(this)));
 }
 
 RendererOverridesHandler::~RendererOverridesHandler() {}
 
 void RendererOverridesHandler::OnClientDetached() {
-  RenderViewHostImpl* host = static_cast<RenderViewHostImpl*>(
-      agent_->GetRenderViewHost());
+  RenderViewHostImpl* host = GetRenderViewHostImpl();
   if (screencast_command_ && host)
     host->SetTouchEventEmulationEnabled(false, false);
   screencast_command_ = NULL;
 }
 
 void RendererOverridesHandler::OnSwapCompositorFrame(
     const cc::CompositorFrameMetadata& frame_metadata) {
   last_compositor_frame_metadata_ = frame_metadata;
   has_last_compositor_frame_metadata_ = true;
 
   if (screencast_command_)
     InnerSwapCompositorFrame();
 }
 
 void RendererOverridesHandler::OnVisibilityChanged(bool visible) {
   if (!screencast_command_)
     return;
   NotifyScreencastVisibility(visible);
 }
 
 void RendererOverridesHandler::OnRenderViewHostChanged() {
-  RenderViewHostImpl* host = static_cast<RenderViewHostImpl*>(
-      agent_->GetRenderViewHost());
+  RenderViewHostImpl* host = GetRenderViewHostImpl();
   if (screencast_command_ && host)
     host->SetTouchEventEmulationEnabled(true, true);
 }
 
 bool RendererOverridesHandler::OnSetTouchEventEmulationEnabled() {
   return screencast_command_.get() != NULL;
 }
 
 void RendererOverridesHandler::InnerSwapCompositorFrame() {
   if ((base::TimeTicks::Now() - last_frame_time_).InMilliseconds() <
           kFrameRateThresholdMs) {
     return;
   }
 
-  RenderViewHost* host = agent_->GetRenderViewHost();
+  RenderViewHost* host = GetRenderViewHostImpl();
   if (!host->GetView())
     return;
 
   last_frame_time_ = base::TimeTicks::Now();
 
   RenderWidgetHostViewBase* view = static_cast<RenderWidgetHostViewBase*>(
       host->GetView());
   // TODO(vkuzkokov): do not use previous frame metadata.
   cc::CompositorFrameMetadata& metadata = last_compositor_frame_metadata_;
 
@@ skipping 61 matching lines @@
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::GrantPermissionsForSetFileInputFiles(
     scoped_refptr<DevToolsProtocol::Command> command) {
   base::DictionaryValue* params = command->params();
   base::ListValue* file_list = NULL;
   const char* param =
       devtools::DOM::setFileInputFiles::kParamFiles;
   if (!params || !params->GetList(param, &file_list))
     return command->InvalidParamResponse(param);
-  RenderViewHost* host = agent_->GetRenderViewHost();
+  RenderViewHost* host = GetRenderViewHostImpl();
   if (!host)
     return NULL;
 
   for (size_t i = 0; i < file_list->GetSize(); ++i) {
     base::FilePath::StringType file;
     if (!file_list->GetString(i, &file))
       return command->InvalidParamResponse(param);
     ChildProcessSecurityPolicyImpl::GetInstance()->GrantReadFile(
         host->GetProcess()->GetID(), base::FilePath(file));
   }
   return NULL;
 }
 
 
 // Network agent handlers  ----------------------------------------------------
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::ClearBrowserCache(
     scoped_refptr<DevToolsProtocol::Command> command) {
-  GetContentClient()->browser()->ClearCache(agent_->GetRenderViewHost());
+  GetContentClient()->browser()->ClearCache(GetRenderViewHostImpl());
   return command->SuccessResponse(NULL);
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::ClearBrowserCookies(
     scoped_refptr<DevToolsProtocol::Command> command) {
-  GetContentClient()->browser()->ClearCookies(agent_->GetRenderViewHost());
+  GetContentClient()->browser()->ClearCookies(GetRenderViewHostImpl());
   return command->SuccessResponse(NULL);
 }
 
 
 // Page agent handlers  -------------------------------------------------------
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageDisable(
     scoped_refptr<DevToolsProtocol::Command> command) {
-  RenderViewHostImpl* host = static_cast<RenderViewHostImpl*>(
-      agent_->GetRenderViewHost());
+  RenderViewHostImpl* host = GetRenderViewHostImpl();
   if (screencast_command_ && host)
     host->SetTouchEventEmulationEnabled(false, false);
   screencast_command_ = NULL;
   return NULL;
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageHandleJavaScriptDialog(
     scoped_refptr<DevToolsProtocol::Command> command) {
   base::DictionaryValue* params = command->params();
   const char* paramAccept =
       devtools::Page::handleJavaScriptDialog::kParamAccept;
   bool accept = false;
   if (!params || !params->GetBoolean(paramAccept, &accept))
     return command->InvalidParamResponse(paramAccept);
   base::string16 prompt_override;
   base::string16* prompt_override_ptr = &prompt_override;
   if (!params || !params->GetString(
       devtools::Page::handleJavaScriptDialog::kParamPromptText,
       prompt_override_ptr)) {
     prompt_override_ptr = NULL;
   }
 
-  RenderViewHost* host = agent_->GetRenderViewHost();
-  if (host) {
-    WebContents* web_contents = host->GetDelegate()->GetAsWebContents();
-    if (web_contents) {
-      JavaScriptDialogManager* manager =
-          web_contents->GetDelegate()->GetJavaScriptDialogManager();
-      if (manager && manager->HandleJavaScriptDialog(
-              web_contents, accept, prompt_override_ptr)) {
-        return command->SuccessResponse(new base::DictionaryValue());
-      }
+  WebContents* web_contents = agent_->GetWebContents();
+  if (web_contents) {
+    JavaScriptDialogManager* manager =
+        web_contents->GetDelegate()->GetJavaScriptDialogManager();
+    if (manager && manager->HandleJavaScriptDialog(
+            web_contents, accept, prompt_override_ptr)) {
+      return command->SuccessResponse(new base::DictionaryValue());
     }
   }
   return command->InternalErrorResponse("No JavaScript dialog to handle");
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageNavigate(
     scoped_refptr<DevToolsProtocol::Command> command) {
   base::DictionaryValue* params = command->params();
   std::string url;
   const char* param = devtools::Page::navigate::kParamUrl;
   if (!params || !params->GetString(param, &url))
     return command->InvalidParamResponse(param);
+
   GURL gurl(url);
-  if (!gurl.is_valid()) {
+  if (!gurl.is_valid())
     return command->InternalErrorResponse("Cannot navigate to invalid URL");
+
+  WebContents* web_contents = agent_->GetWebContents();
+  if (web_contents) {
+    web_contents->GetController()
+        .LoadURL(gurl, Referrer(), PAGE_TRANSITION_TYPED, std::string());
+    // Fall through into the renderer.
+    return NULL;
   }
-  RenderViewHost* host = agent_->GetRenderViewHost();
-  if (host) {
-    WebContents* web_contents = host->GetDelegate()->GetAsWebContents();
-    if (web_contents) {
-      web_contents->GetController()
-          .LoadURL(gurl, Referrer(), PAGE_TRANSITION_TYPED, std::string());
-      // Fall through into the renderer.
-      return NULL;
-    }
-  }
+
   return command->InternalErrorResponse("No WebContents to navigate");
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageReload(
     scoped_refptr<DevToolsProtocol::Command> command) {
-  RenderViewHost* host = agent_->GetRenderViewHost();
-  if (host) {
-    WebContents* web_contents = host->GetDelegate()->GetAsWebContents();
-    if (web_contents) {
-      // Override only if it is crashed.
-      if (!web_contents->IsCrashed())
-        return NULL;
+  WebContents* web_contents = agent_->GetWebContents();
+  if (web_contents) {
+    // Override only if it is crashed.
+    if (!web_contents->IsCrashed())
+      return NULL;
 
-      web_contents->GetController().Reload(false);
-      return command->SuccessResponse(NULL);
-    }
+    web_contents->GetController().Reload(false);
+    return command->SuccessResponse(NULL);
   }
   return command->InternalErrorResponse("No WebContents to reload");
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageGetNavigationHistory(
     scoped_refptr<DevToolsProtocol::Command> command) {
-  RenderViewHost* host = agent_->GetRenderViewHost();
-  if (host) {
-    WebContents* web_contents = host->GetDelegate()->GetAsWebContents();
-    if (web_contents) {
-      base::DictionaryValue* result = new base::DictionaryValue();
-      NavigationController& controller = web_contents->GetController();
-      result->SetInteger(
-          devtools::Page::getNavigationHistory::kResponseCurrentIndex,
-          controller.GetCurrentEntryIndex());
-      base::ListValue* entries = new base::ListValue();
-      for (int i = 0; i != controller.GetEntryCount(); ++i) {
-        const NavigationEntry* entry = controller.GetEntryAtIndex(i);
-        base::DictionaryValue* entry_value = new base::DictionaryValue();
-        entry_value->SetInteger(
-            devtools::Page::NavigationEntry::kParamId,
-            entry->GetUniqueID());
-        entry_value->SetString(
-            devtools::Page::NavigationEntry::kParamUrl,
-            entry->GetURL().spec());
-        entry_value->SetString(
-            devtools::Page::NavigationEntry::kParamTitle,
-            entry->GetTitle());
-        entries->Append(entry_value);
-      }
-      result->Set(
-          devtools::Page::getNavigationHistory::kResponseEntries,
-          entries);
-      return command->SuccessResponse(result);
+  WebContents* web_contents = agent_->GetWebContents();
+  if (web_contents) {
+    base::DictionaryValue* result = new base::DictionaryValue();
+    NavigationController& controller = web_contents->GetController();
+    result->SetInteger(
+        devtools::Page::getNavigationHistory::kResponseCurrentIndex,
+        controller.GetCurrentEntryIndex());
+    base::ListValue* entries = new base::ListValue();
+    for (int i = 0; i != controller.GetEntryCount(); ++i) {
+      const NavigationEntry* entry = controller.GetEntryAtIndex(i);
+      base::DictionaryValue* entry_value = new base::DictionaryValue();
+      entry_value->SetInteger(
+          devtools::Page::NavigationEntry::kParamId,
+          entry->GetUniqueID());
+      entry_value->SetString(
+          devtools::Page::NavigationEntry::kParamUrl,
+          entry->GetURL().spec());
+      entry_value->SetString(
+          devtools::Page::NavigationEntry::kParamTitle,
+          entry->GetTitle());
+      entries->Append(entry_value);
     }
+    result->Set(
+        devtools::Page::getNavigationHistory::kResponseEntries,
+        entries);
+    return command->SuccessResponse(result);
   }
   return command->InternalErrorResponse("No WebContents to navigate");
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageNavigateToHistoryEntry(
     scoped_refptr<DevToolsProtocol::Command> command) {
   base::DictionaryValue* params = command->params();
   const char* param = devtools::Page::navigateToHistoryEntry::kParamEntryId;
   int entry_id = 0;
   if (!params || !params->GetInteger(param, &entry_id)) {
     return command->InvalidParamResponse(param);
   }
 
-  RenderViewHost* host = agent_->GetRenderViewHost();
-  if (host) {
-    WebContents* web_contents = host->GetDelegate()->GetAsWebContents();
-    if (web_contents) {
-      NavigationController& controller = web_contents->GetController();
-      for (int i = 0; i != controller.GetEntryCount(); ++i) {
-        if (controller.GetEntryAtIndex(i)->GetUniqueID() == entry_id) {
-          controller.GoToIndex(i);
-          return command->SuccessResponse(new base::DictionaryValue());
-        }
+  WebContents* web_contents = agent_->GetWebContents();
+  if (web_contents) {
+    NavigationController& controller = web_contents->GetController();
+    for (int i = 0; i != controller.GetEntryCount(); ++i) {
+      if (controller.GetEntryAtIndex(i)->GetUniqueID() == entry_id) {
+        controller.GoToIndex(i);
+        return command->SuccessResponse(new base::DictionaryValue());
       }
-      return command->InvalidParamResponse(param);
     }
+    return command->InvalidParamResponse(param);
   }
   return command->InternalErrorResponse("No WebContents to navigate");
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageCaptureScreenshot(
     scoped_refptr<DevToolsProtocol::Command> command) {
-  RenderViewHostImpl* host = static_cast<RenderViewHostImpl*>(
-      agent_->GetRenderViewHost());
+  RenderViewHostImpl* host = GetRenderViewHostImpl();
   if (!host->GetView())
     return command->InternalErrorResponse("Unable to access the view");
 
   host->GetSnapshotFromBrowser(
       base::Bind(&RendererOverridesHandler::ScreenshotCaptured,
           weak_factory_.GetWeakPtr(), command));
   return command->AsyncResponsePromise();
 }
 
 void RendererOverridesHandler::ScreenshotCaptured(
@@ skipping 27 matching lines @@
 #else
   result->SetBoolean(devtools::kResult, false);
 #endif  // defined(OS_ANDROID)
   return command->SuccessResponse(result);
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageStartScreencast(
     scoped_refptr<DevToolsProtocol::Command> command) {
   screencast_command_ = command;
-  RenderViewHostImpl* host = static_cast<RenderViewHostImpl*>(
-      agent_->GetRenderViewHost());
+  RenderViewHostImpl* host = GetRenderViewHostImpl();
   host->SetTouchEventEmulationEnabled(true, true);
   bool visible = !host->is_hidden();
   NotifyScreencastVisibility(visible);
   if (visible) {
     if (has_last_compositor_frame_metadata_)
       InnerSwapCompositorFrame();
     else
       host->Send(new ViewMsg_ForceRedraw(host->GetRoutingID(), 0));
   }
   return command->SuccessResponse(NULL);
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageStopScreencast(
     scoped_refptr<DevToolsProtocol::Command> command) {
   last_frame_time_ = base::TimeTicks();
   screencast_command_ = NULL;
-  RenderViewHostImpl* host = static_cast<RenderViewHostImpl*>(
-      agent_->GetRenderViewHost());
+  RenderViewHostImpl* host = GetRenderViewHostImpl();
   if (host)
     host->SetTouchEventEmulationEnabled(false, false);
   return command->SuccessResponse(NULL);
 }
 
 void RendererOverridesHandler::ScreencastFrameCaptured(
     const std::string& format,
     int quality,
     const cc::CompositorFrameMetadata& metadata,
     bool success,
@@ skipping 272 matching lines @@
       &security_origin)) {
     return command->InvalidParamResponse(
         devtools::Page::queryUsageAndQuota::kParamSecurityOrigin);
   }
 
   ResponseCallback callback = base::Bind(
       &RendererOverridesHandler::PageQueryUsageAndQuotaCompleted,
       weak_factory_.GetWeakPtr(),
       command);
 
-  scoped_refptr<quota::QuotaManager> quota_manager =
-      agent_->GetRenderViewHost()->GetProcess()->
-          GetStoragePartition()->GetQuotaManager();
+  scoped_refptr<quota::QuotaManager> quota_manager = GetRenderViewHostImpl()
+                                                         ->GetProcess()
+                                                         ->GetStoragePartition()
+                                                         ->GetQuotaManager();
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(
           &QueryUsageAndQuotaOnIOThread,
           quota_manager,
           GURL(security_origin),
           callback));
 
   return command->AsyncResponsePromise();
@@ skipping 20 matching lines @@
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::InputEmulateTouchFromMouseEvent(
     scoped_refptr<DevToolsProtocol::Command> command) {
   if (!screencast_command_)
     return command->InternalErrorResponse("Screencast should be turned on");
 
   base::DictionaryValue* params = command->params();
   if (!params)
     return command->NoSuchMethodErrorResponse();
 
-  RenderViewHost* host = agent_->GetRenderViewHost();
-
   std::string type;
   if (!params->GetString(
           devtools::Input::emulateTouchFromMouseEvent::kParamType,
           &type)) {
     return command->InvalidParamResponse(
         devtools::Input::emulateTouchFromMouseEvent::kParamType);
   }
 
   blink::WebMouseWheelEvent wheel_event;
   blink::WebMouseEvent mouse_event;
@@ skipping 89 matching lines @@
     event->button = WebMouseEvent::ButtonMiddle;
     event->modifiers |= WebInputEvent::MiddleButtonDown;
   } else if (button == "right") {
     event->button = WebMouseEvent::ButtonRight;
     event->modifiers |= WebInputEvent::RightButtonDown;
   } else {
     return command->InvalidParamResponse(
         devtools::Input::emulateTouchFromMouseEvent::kParamButton);
   }
 
+  RenderViewHost* host = GetRenderViewHostImpl();
   if (event->type == WebInputEvent::MouseWheel)
     host->ForwardWheelEvent(wheel_event);
   else
     host->ForwardMouseEvent(mouse_event);
   return command->SuccessResponse(NULL);
 }
 
+RenderViewHostImpl* RendererOverridesHandler::GetRenderViewHostImpl() {
+  return static_cast<RenderViewHostImpl*>(
+      agent_->GetWebContents()->GetRenderViewHost());
+}
+
 }  // namespace content