DevTools: extract bindings from ShellDevToolsFrontend

content/shell/browser/layout_test/blink_test_controller.cc

 // Copyright 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/shell/browser/layout_test/blink_test_controller.h"
 
 #include <stddef.h>
 
 #include <iostream>
 #include <set>
@@ skipping 25 matching lines @@
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/service_worker_context.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/associated_interface_provider.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 #include "content/shell/browser/layout_test/layout_test_bluetooth_chooser_factory.h"
-#include "content/shell/browser/layout_test/layout_test_devtools_frontend.h"
+#include "content/shell/browser/layout_test/layout_test_devtools_bindings.h"
 #include "content/shell/browser/layout_test/layout_test_first_device_bluetooth_chooser.h"
 #include "content/shell/browser/shell.h"
 #include "content/shell/browser/shell_browser_context.h"
 #include "content/shell/browser/shell_content_browser_client.h"
 #include "content/shell/browser/shell_devtools_frontend.h"
 #include "content/shell/common/layout_test/layout_test_messages.h"
 #include "content/shell/common/layout_test/layout_test_switches.h"
 #include "content/shell/common/shell_messages.h"
 #include "content/shell/renderer/layout_test/blink_test_helpers.h"
 #include "ui/gfx/codec/png_codec.h"
@@ skipping 168 matching lines @@
   return instance_;
 }
 
 BlinkTestController::BlinkTestController()
     : main_window_(NULL),
       test_phase_(BETWEEN_TESTS),
       is_leak_detection_enabled_(
           base::CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kEnableLeakDetection)),
       crash_when_leak_found_(false),
-      devtools_frontend_(NULL),
       render_process_host_observer_(this) {
   CHECK(!instance_);
   instance_ = this;
 
   if (is_leak_detection_enabled_) {
     std::string switchValue =
         base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
             switches::kEnableLeakDetection);
     crash_when_leak_found_ = switchValue == switches::kCrashOnFailure;
   }
@@ skipping 24 matching lines @@
     bool enable_pixel_dumping,
     const std::string& expected_pixel_hash) {
   DCHECK(CalledOnValidThread());
   test_phase_ = DURING_TEST;
   current_working_directory_ = current_working_directory;
   enable_pixel_dumping_ = enable_pixel_dumping;
   expected_pixel_hash_ = expected_pixel_hash;
   if (test_url.spec().find("/inspector-unit/") == std::string::npos)
     test_url_ = test_url;
   else
-    test_url_ = LayoutTestDevToolsFrontend::MapJSTestURL(test_url);
+    test_url_ = LayoutTestDevToolsBindings::MapJSTestURL(test_url);
   did_send_initial_test_configuration_ = false;
   printer_->reset();
   frame_to_layout_dump_map_.clear();
   render_process_host_observer_.RemoveAll();
   all_observed_render_process_hosts_.clear();
   main_window_render_process_hosts_.clear();
   accumulated_layout_test_runtime_flags_changes_.Clear();
   layout_test_control_map_.clear();
   ShellBrowserContext* browser_context =
       ShellContentBrowserClient::Get()->browser_context();
@@ skipping 196 matching lines @@
 
 void BlinkTestController::RenderFrameCreated(
     RenderFrameHost* render_frame_host) {
   DCHECK(CalledOnValidThread());
   HandleNewRenderFrameHost(render_frame_host);
 }
 
 void BlinkTestController::DevToolsProcessCrashed() {
   DCHECK(CalledOnValidThread());
   printer_->AddErrorMessage("#CRASHED - devtools");
-  if (devtools_frontend_)
-      devtools_frontend_->Close();
-  devtools_frontend_ = NULL;
+  devtools_bindings_.reset();
+  devtools_window_.reset();
 }
 
 void BlinkTestController::WebContentsDestroyed() {
   DCHECK(CalledOnValidThread());
   printer_->AddErrorMessage("FAIL: main window was destroyed");
   DiscardMainWindow();
 }
 
 void BlinkTestController::RenderProcessHostDestroyed(
     RenderProcessHost* render_process_host) {
@@ skipping 60 matching lines @@
     base::TerminationStatus exit_code) {
   DCHECK(CalledOnValidThread());
   printer_->AddErrorMessage("#CRASHED - gpu");
   DiscardMainWindow();
 }
 
 void BlinkTestController::DiscardMainWindow() {
   // If we're running a test, we need to close all windows and exit the message
   // loop. Otherwise, we're already outside of the message loop, and we just
   // discard the main window.
+  devtools_bindings_.reset();
   WebContentsObserver::Observe(NULL);
   if (test_phase_ != BETWEEN_TESTS) {
     Shell::CloseAllWindows();
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
     test_phase_ = CLEAN_UP;
   } else if (main_window_) {
     main_window_->Close();
   }
   main_window_ = NULL;
@@ skipping 208 matching lines @@
       main_window_->web_contents()->GetRenderViewHost();
   main_render_view_host->OnWebkitPreferencesChanged();
 }
 
 void BlinkTestController::OnClearDevToolsLocalStorage() {
   ShellBrowserContext* browser_context =
       ShellContentBrowserClient::Get()->browser_context();
   StoragePartition* storage_partition =
       BrowserContext::GetStoragePartition(browser_context, NULL);
   storage_partition->GetDOMStorageContext()->DeleteLocalStorage(
-      content::LayoutTestDevToolsFrontend::GetDevToolsPathAsURL("")
+      content::LayoutTestDevToolsBindings::GetDevToolsPathAsURL("")
           .GetOrigin());
 }
 
 void BlinkTestController::OnShowDevTools(const std::string& settings,
                                          const std::string& frontend_url) {
-  if (!devtools_frontend_) {
-    devtools_frontend_ = LayoutTestDevToolsFrontend::Show(
-        main_window_->web_contents(), settings, frontend_url);
-  } else {
-    devtools_frontend_->ReuseFrontend(settings, frontend_url);
+  if (!devtools_window_) {
+    ShellBrowserContext* browser_context =
+        ShellContentBrowserClient::Get()->browser_context();
+    devtools_window_.reset(content::Shell::CreateNewWindow(
+        browser_context, GURL(), nullptr, initial_size_));
   }
-  devtools_frontend_->Activate();
-  devtools_frontend_->Focus();
+  devtools_bindings_.reset(new LayoutTestDevToolsBindings(
+      devtools_window_->web_contents(), main_window_->web_contents()));
+  devtools_bindings_->LoadDevTools(settings, frontend_url);
+  devtools_window_->web_contents()->GetRenderViewHost()->GetWidget()->Focus();
+  devtools_window_->web_contents()->Focus();
 }
 
 void BlinkTestController::OnEvaluateInDevTools(
     int call_id, const std::string& script) {
-  if (devtools_frontend_)
-    devtools_frontend_->EvaluateInFrontend(call_id, script);
+  if (devtools_bindings_)
+    devtools_bindings_->EvaluateInFrontend(call_id, script);
 }
 
 void BlinkTestController::OnCloseDevTools() {
-  if (devtools_frontend_)
-    devtools_frontend_->DisconnectFromTarget();
+  devtools_bindings_.reset();
 }
 
 void BlinkTestController::OnGoToOffset(int offset) {
   main_window_->GoBackOrForward(offset);
 }
 
 void BlinkTestController::OnReload() {
   main_window_->Reload();
 }
 
@@ skipping 40 matching lines @@
       main_window_->web_contents()->GetRenderViewHost();
   Send(new ShellViewMsg_SessionHistory(render_view_host->GetRoutingID(),
                                        routing_ids,
                                        session_histories,
                                        current_entry_indexes));
 }
 
 void BlinkTestController::OnCloseRemainingWindows() {
   DevToolsAgentHost::DetachAllClients();
   std::vector<Shell*> open_windows(Shell::windows());
-  Shell* devtools_shell = devtools_frontend_ ?
-      devtools_frontend_->frontend_shell() : NULL;
   for (size_t i = 0; i < open_windows.size(); ++i) {
-    if (open_windows[i] != main_window_ && open_windows[i] != devtools_shell)
+    if (open_windows[i] != main_window_ &&
+        open_windows[i] != devtools_window_.get())
       open_windows[i]->Close();
   }
   base::RunLoop().RunUntilIdle();
 }
 
 void BlinkTestController::OnResetDone() {
   if (is_leak_detection_enabled_) {
     if (main_window_ && main_window_->web_contents()) {
       RenderViewHost* render_view_host =
           main_window_->web_contents()->GetRenderViewHost();
@@ skipping 78 matching lines @@
   }
   DCHECK(layout_test_control_map_[frame].get());
   return layout_test_control_map_[frame].get();
 }
 
 void BlinkTestController::HandleLayoutTestControlError(RenderFrameHost* frame) {
   layout_test_control_map_.erase(frame);
 }
 
 }  // namespace content