chrome/browser/devtools/devtools_window.cc - Issue 253823005: DevTools: extract DevToolsWindowBase, leave docking, unload and factory logic in DevToolsWindow.

Unified Diff: chrome/browser/devtools/devtools_window.cc

Issue 253823005: DevTools: extract DevToolsWindowBase, leave docking, unload and factory logic in DevToolsWindow. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src

Patch Set: Created 6 years, 8 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

« no previous file with comments | « chrome/browser/devtools/devtools_window.h ('k') | chrome/browser/devtools/devtools_window_base.h » ('j') | chrome/browser/devtools/devtools_window_base.h » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: chrome/browser/devtools/devtools_window.cc

diff --git a/chrome/browser/devtools/devtools_window.cc b/chrome/browser/devtools/devtools_window.cc

index 8b12c800b818c4656324a75793a00c86ca1ddce8..b981cbe567c89c039d8d15705875dae37389cbd9 100644

--- a/chrome/browser/devtools/devtools_window.cc

+++ b/chrome/browser/devtools/devtools_window.cc

@@ -14,24 +14,13 @@

#include "base/prefs/scoped_user_pref_update.h"

#include "base/strings/string_number_conversions.h"

#include "base/strings/string_util.h"

-#include "base/strings/utf_string_conversions.h"

#include "base/time/time.h"

#include "base/values.h"

-#include "chrome/browser/browser_process.h"

-#include "chrome/browser/chrome_notification_types.h"

#include "chrome/browser/chrome_page_zoom.h"

-#include "chrome/browser/extensions/api/debugger/debugger_api.h"

-#include "chrome/browser/extensions/chrome_extension_web_contents_observer.h"

-#include "chrome/browser/extensions/extension_service.h"

#include "chrome/browser/file_select_helper.h"

-#include "chrome/browser/infobars/confirm_infobar_delegate.h"

-#include "chrome/browser/infobars/infobar_service.h"

#include "chrome/browser/prefs/pref_service_syncable.h"

#include "chrome/browser/profiles/profile.h"

#include "chrome/browser/sessions/session_tab_helper.h"

-#include "chrome/browser/themes/theme_properties.h"

-#include "chrome/browser/themes/theme_service.h"

-#include "chrome/browser/themes/theme_service_factory.h"

#include "chrome/browser/ui/browser.h"

#include "chrome/browser/ui/browser_dialogs.h"

#include "chrome/browser/ui/browser_iterator.h"

@@ -42,19 +31,14 @@

#include "chrome/browser/ui/tabs/tab_strip_model.h"

#include "chrome/browser/ui/webui/devtools_ui.h"

#include "chrome/common/chrome_switches.h"

-#include "chrome/common/extensions/manifest_url_handler.h"

#include "chrome/common/pref_names.h"

#include "chrome/common/render_messages.h"

#include "chrome/common/url_constants.h"

-#include "components/infobars/core/infobar.h"

#include "components/user_prefs/pref_registry_syncable.h"

#include "content/public/browser/browser_thread.h"

-#include "content/public/browser/child_process_security_policy.h"

#include "content/public/browser/devtools_agent_host.h"

#include "content/public/browser/devtools_client_host.h"

#include "content/public/browser/devtools_manager.h"

-#include "content/public/browser/favicon_status.h"

-#include "content/public/browser/load_notification_details.h"

#include "content/public/browser/native_web_keyboard_event.h"

#include "content/public/browser/navigation_controller.h"

#include "content/public/browser/navigation_entry.h"

@@ -66,111 +50,32 @@

#include "content/public/browser/web_contents.h"

#include "content/public/browser/web_contents_observer.h"

#include "content/public/browser/web_contents_view.h"

-#include "content/public/common/bindings_policy.h"

#include "content/public/common/content_client.h"

#include "content/public/common/page_transition_types.h"

-#include "content/public/common/renderer_preferences.h"

#include "content/public/common/url_constants.h"

#include "content/public/test/test_utils.h"

-#include "extensions/browser/extension_system.h"

-#include "extensions/common/extension_set.h"

-#include "grit/generated_resources.h"

#include "third_party/WebKit/public/web/WebInputEvent.h"

-#include "ui/base/l10n/l10n_util.h"

#include "ui/events/keycodes/keyboard_codes.h"

using base::DictionaryValue;

using blink::WebInputEvent;

using content::BrowserThread;

using content::DevToolsAgentHost;

-// DevToolsConfirmInfoBarDelegate ---------------------------------------------

-class DevToolsConfirmInfoBarDelegate : public ConfirmInfoBarDelegate {

- public:

- // If |infobar_service| is NULL, runs |callback| with a single argument with

- // value "false". Otherwise, creates a dev tools confirm infobar and delegate

- // and adds the infobar to |infobar_service|.

- static void Create(InfoBarService* infobar_service,

- const DevToolsWindow::InfoBarCallback& callback,

- const base::string16& message);

- private:

- DevToolsConfirmInfoBarDelegate(

- const DevToolsWindow::InfoBarCallback& callback,

- const base::string16& message);

- virtual ~DevToolsConfirmInfoBarDelegate();

- virtual base::string16 GetMessageText() const OVERRIDE;

- virtual base::string16 GetButtonLabel(InfoBarButton button) const OVERRIDE;

- virtual bool Accept() OVERRIDE;

- virtual bool Cancel() OVERRIDE;

- DevToolsWindow::InfoBarCallback callback_;

- const base::string16 message_;

- DISALLOW_COPY_AND_ASSIGN(DevToolsConfirmInfoBarDelegate);

-};

-void DevToolsConfirmInfoBarDelegate::Create(

- InfoBarService* infobar_service,

- const DevToolsWindow::InfoBarCallback& callback,

- const base::string16& message) {

- if (!infobar_service) {

- callback.Run(false);

- return;

- }

- infobar_service->AddInfoBar(ConfirmInfoBarDelegate::CreateInfoBar(

- scoped_ptr<ConfirmInfoBarDelegate>(

- new DevToolsConfirmInfoBarDelegate(callback, message))));

-DevToolsConfirmInfoBarDelegate::DevToolsConfirmInfoBarDelegate(

- const DevToolsWindow::InfoBarCallback& callback,

- const base::string16& message)

- : ConfirmInfoBarDelegate(),

- callback_(callback),

- message_(message) {

-DevToolsConfirmInfoBarDelegate::~DevToolsConfirmInfoBarDelegate() {

- if (!callback_.is_null())

- callback_.Run(false);

-base::string16 DevToolsConfirmInfoBarDelegate::GetMessageText() const {

- return message_;

-base::string16 DevToolsConfirmInfoBarDelegate::GetButtonLabel(

- InfoBarButton button) const {

- return l10n_util::GetStringUTF16((button == BUTTON_OK) ?

- IDS_DEV_TOOLS_CONFIRM_ALLOW_BUTTON : IDS_DEV_TOOLS_CONFIRM_DENY_BUTTON);

-bool DevToolsConfirmInfoBarDelegate::Accept() {

- callback_.Run(true);

- callback_.Reset();

- return true;

-bool DevToolsConfirmInfoBarDelegate::Cancel() {

- callback_.Run(false);

- callback_.Reset();

- return true;

-// DevToolsEventForwarder -----------------------------------------------------

+using content::WebContents;

namespace {

+typedef std::vector<DevToolsWindow*> DevToolsWindows;

+base::LazyInstance<DevToolsWindows>::Leaky g_instances =

+ LAZY_INSTANCE_INITIALIZER;

static const char kKeyUpEventName[] = "keyup";

static const char kKeyDownEventName[] = "keydown";

} // namespace

+// DevToolsEventForwarder -----------------------------------------------------

class DevToolsEventForwarder {

public:

explicit DevToolsEventForwarder(DevToolsWindow* window)

@@ -285,10 +190,10 @@ int DevToolsEventForwarder::VirtualKeyCodeWithoutLocation(int key_code)

class DevToolsWindow::InspectedWebContentsObserver

: public content::WebContentsObserver {

public:

- explicit InspectedWebContentsObserver(content::WebContents* web_contents);

+ explicit InspectedWebContentsObserver(WebContents* web_contents);

virtual ~InspectedWebContentsObserver();

- content::WebContents* web_contents() {

+ WebContents* web_contents() {

return WebContentsObserver::web_contents();

}

@@ -297,94 +202,18 @@ class DevToolsWindow::InspectedWebContentsObserver

};

DevToolsWindow::InspectedWebContentsObserver::InspectedWebContentsObserver(

- content::WebContents* web_contents)

+ WebContents* web_contents)

: WebContentsObserver(web_contents) {

}

DevToolsWindow::InspectedWebContentsObserver::~InspectedWebContentsObserver() {

}

-// DevToolsWindow::FrontendWebContentsObserver --------------------------------

-class DevToolsWindow::FrontendWebContentsObserver

- : public content::WebContentsObserver {

- public:

- explicit FrontendWebContentsObserver(DevToolsWindow* window);

- virtual ~FrontendWebContentsObserver();

- private:

- // contents::WebContentsObserver:

- virtual void AboutToNavigateRenderView(

- content::RenderViewHost* render_view_host) OVERRIDE;

- virtual void DocumentOnLoadCompletedInMainFrame(int32 page_id) OVERRIDE;

- virtual void WebContentsDestroyed(content::WebContents*) OVERRIDE;

- DevToolsWindow* devtools_window_;

- DISALLOW_COPY_AND_ASSIGN(FrontendWebContentsObserver);

-};

-DevToolsWindow::FrontendWebContentsObserver::FrontendWebContentsObserver(

- DevToolsWindow* devtools_window)

- : WebContentsObserver(devtools_window->web_contents()),

- devtools_window_(devtools_window) {

-void DevToolsWindow::FrontendWebContentsObserver::WebContentsDestroyed(

- content::WebContents* contents) {

- delete devtools_window_;

-DevToolsWindow::FrontendWebContentsObserver::~FrontendWebContentsObserver() {

-void DevToolsWindow::FrontendWebContentsObserver::AboutToNavigateRenderView(

- content::RenderViewHost* render_view_host) {

- content::DevToolsClientHost::SetupDevToolsFrontendClient(render_view_host);

-void DevToolsWindow::FrontendWebContentsObserver::

- DocumentOnLoadCompletedInMainFrame(int32 page_id) {

- devtools_window_->DocumentOnLoadCompletedInMainFrame();

// DevToolsWindow -------------------------------------------------------------

-namespace {

-typedef std::vector<DevToolsWindow*> DevToolsWindows;

-base::LazyInstance<DevToolsWindows>::Leaky g_instances =

- LAZY_INSTANCE_INITIALIZER;

-static const char kFrontendHostId[] = "id";

-static const char kFrontendHostMethod[] = "method";

-static const char kFrontendHostParams[] = "params";

-std::string SkColorToRGBAString(SkColor color) {

- // We avoid StringPrintf because it will use locale specific formatters for

- // the double (e.g. ',' instead of '.' in German).

- return "rgba(" + base::IntToString(SkColorGetR(color)) + "," +

- base::IntToString(SkColorGetG(color)) + "," +

- base::IntToString(SkColorGetB(color)) + "," +

- base::DoubleToString(SkColorGetA(color) / 255.0) + ")";

-base::DictionaryValue* CreateFileSystemValue(

- DevToolsFileHelper::FileSystem file_system) {

- base::DictionaryValue* file_system_value = new base::DictionaryValue();

- file_system_value->SetString("fileSystemName", file_system.file_system_name);

- file_system_value->SetString("rootURL", file_system.root_url);

- file_system_value->SetString("fileSystemPath", file_system.file_system_path);

- return file_system_value;

-} // namespace

const char DevToolsWindow::kDevToolsApp[] = "DevToolsApp";

DevToolsWindow::~DevToolsWindow() {

- content::DevToolsManager::GetInstance()->ClientHostClosing(

- frontend_host_.get());

UpdateBrowserToolbar();

DevToolsWindows* instances = g_instances.Pointer();

@@ -392,14 +221,6 @@ DevToolsWindow::~DevToolsWindow() {

std::find(instances->begin(), instances->end(), this));

DCHECK(it != instances->end());

instances->erase(it);

- for (IndexingJobsMap::const_iterator jobs_it(indexing_jobs_.begin());

- jobs_it != indexing_jobs_.end(); ++jobs_it) {

- jobs_it->second->Stop();

- }

- indexing_jobs_.clear();

- if (device_listener_enabled_)

- EnableRemoteDeviceCounter(false);

}

// static

@@ -444,7 +265,7 @@ void DevToolsWindow::RegisterProfilePrefs(

// static

DevToolsWindow* DevToolsWindow::GetDockedInstanceForInspectedTab(

- content::WebContents* inspected_web_contents) {

+ WebContents* inspected_web_contents) {

DevToolsWindow* window = GetInstanceForInspectedRenderViewHost(

inspected_web_contents->GetRenderViewHost());

if (!window)

@@ -469,7 +290,7 @@ DevToolsWindow* DevToolsWindow::GetInstanceForInspectedRenderViewHost(

// static

DevToolsWindow* DevToolsWindow::GetInstanceForInspectedWebContents(

- content::WebContents* inspected_web_contents) {

+ WebContents* inspected_web_contents) {

if (!inspected_web_contents)

return NULL;

return GetInstanceForInspectedRenderViewHost(

@@ -490,7 +311,7 @@ DevToolsWindow* DevToolsWindow::OpenDevToolsWindowForWorker(

window = DevToolsWindow::CreateDevToolsWindowForWorker(profile);

// Will disconnect the current client host if there is one.

content::DevToolsManager::GetInstance()->RegisterDevToolsClientHostFor(

- worker_agent, window->frontend_host_.get());

+ worker_agent, window->frontend_host());

}

window->ScheduleShow(DevToolsToggleAction::Show());

return window;

@@ -561,7 +382,7 @@ void DevToolsWindow::OpenExternalFrontend(

window = Create(profile, DevToolsUI::GetProxyURL(frontend_url), NULL,

false, true, false);

content::DevToolsManager::GetInstance()->RegisterDevToolsClientHostFor(

- agent_host, window->frontend_host_.get());

+ agent_host, window->frontend_host());

}

window->ScheduleShow(DevToolsToggleAction::Show());

}

@@ -583,7 +404,7 @@ DevToolsWindow* DevToolsWindow::ToggleDevToolsWindow(

base::UserMetricsAction("DevTools_InspectRenderer"));

window = Create(profile, GURL(), inspected_rvh, false, false, true);

manager->RegisterDevToolsClientHostFor(agent.get(),

- window->frontend_host_.get());

+ window->frontend_host());

do_open = true;

}

@@ -616,18 +437,6 @@ void DevToolsWindow::InspectElement(content::RenderViewHost* inspected_rvh,

window->inspect_element_start_time_ = start_time;

}

-void DevToolsWindow::InspectedContentsClosing() {

- intercepted_page_beforeunload_ = false;

- // This will prevent any activity after frontend is loaded.

- action_on_load_ = DevToolsToggleAction::NoOp();

- ignore_set_is_docked_ = true;

- web_contents_->GetRenderViewHost()->ClosePage();

-content::RenderViewHost* DevToolsWindow::GetRenderViewHost() {

- return web_contents_->GetRenderViewHost();

const DevToolsContentsResizingStrategy&

DevToolsWindow::GetContentsResizingStrategy() const {

return contents_resizing_strategy_;

@@ -670,21 +479,21 @@ void DevToolsWindow::Show(const DevToolsToggleAction& action) {

// Tell inspected browser to update splitter and switch to inspected panel.

BrowserWindow* inspected_window = inspected_browser->window();

- web_contents_->SetDelegate(this);

+ web_contents()->SetDelegate(this);

TabStripModel* tab_strip_model = inspected_browser->tab_strip_model();

tab_strip_model->ActivateTabAt(inspected_tab_index, true);

inspected_window->UpdateDevTools();

- web_contents_->GetView()->SetInitialFocus();

+ web_contents()->GetView()->SetInitialFocus();

inspected_window->Show();

// On Aura, focusing once is not enough. Do it again.

// Note that focusing only here but not before isn't enough either. We just

// need to focus twice.

- web_contents_->GetView()->SetInitialFocus();

+ web_contents()->GetView()->SetInitialFocus();

- PrefsTabHelper::CreateForWebContents(web_contents_);

- GetRenderViewHost()->SyncRendererPrefs();

+ PrefsTabHelper::CreateForWebContents(web_contents());

+ web_contents()->GetRenderViewHost()->SyncRendererPrefs();

DoAction(action);

return;

@@ -700,14 +509,14 @@ void DevToolsWindow::Show(const DevToolsToggleAction& action) {

if (should_show_window) {

browser_->window()->Show();

- web_contents_->GetView()->SetInitialFocus();

+ web_contents()->GetView()->SetInitialFocus();

}

DoAction(action);

}

// static

-bool DevToolsWindow::HandleBeforeUnload(content::WebContents* frontend_contents,

+bool DevToolsWindow::HandleBeforeUnload(WebContents* frontend_contents,

bool proceed, bool* proceed_to_fire_unload) {

DevToolsWindow* window = AsDevToolsWindow(

frontend_contents->GetRenderViewHost());

@@ -721,7 +530,7 @@ bool DevToolsWindow::HandleBeforeUnload(content::WebContents* frontend_contents,

}

// static

-bool DevToolsWindow::InterceptPageBeforeUnload(content::WebContents* contents) {

+bool DevToolsWindow::InterceptPageBeforeUnload(WebContents* contents) {

DevToolsWindow* window =

DevToolsWindow::GetInstanceForInspectedRenderViewHost(

contents->GetRenderViewHost());

@@ -743,7 +552,7 @@ bool DevToolsWindow::InterceptPageBeforeUnload(content::WebContents* contents) {

// static

bool DevToolsWindow::NeedsToInterceptBeforeUnload(

- content::WebContents* contents) {

+ WebContents* contents) {

DevToolsWindow* window =

DevToolsWindow::GetInstanceForInspectedRenderViewHost(

contents->GetRenderViewHost());

@@ -759,7 +568,7 @@ bool DevToolsWindow::HasFiredBeforeUnloadEventForDevToolsBrowser(

// beforeunload.

if (browser->tab_strip_model()->empty())

return true;

- content::WebContents* contents =

+ WebContents* contents =

browser->tab_strip_model()->GetWebContentsAt(0);

DevToolsWindow* window = AsDevToolsWindow(contents->GetRenderViewHost());

if (!window)

@@ -768,7 +577,7 @@ bool DevToolsWindow::HasFiredBeforeUnloadEventForDevToolsBrowser(

}

// static

-void DevToolsWindow::OnPageCloseCanceled(content::WebContents* contents) {

+void DevToolsWindow::OnPageCloseCanceled(WebContents* contents) {

DevToolsWindow *window =

DevToolsWindow::GetInstanceForInspectedRenderViewHost(

contents->GetRenderViewHost());

@@ -783,59 +592,29 @@ DevToolsWindow::DevToolsWindow(Profile* profile,

const GURL& url,

content::RenderViewHost* inspected_rvh,

bool can_dock)

- : profile_(profile),

+ : DevToolsWindowBase(

+ WebContents::Create(WebContents::CreateParams(profile)), url),

browser_(NULL),

is_docked_(true),

can_dock_(can_dock),

- device_listener_enabled_(false),

// This initialization allows external front-end to work without changes.

// We don't wait for docking call, but instead immediately show undocked.

// Passing "dockSide=undocked" parameter ensures proper UI.

load_state_(can_dock ? kNotLoaded : kIsDockedSet),

action_on_load_(DevToolsToggleAction::NoOp()),

ignore_set_is_docked_(false),

- intercepted_page_beforeunload_(false),

- weak_factory_(this) {

- web_contents_ =

- content::WebContents::Create(content::WebContents::CreateParams(profile));

- frontend_contents_observer_.reset(new FrontendWebContentsObserver(this));

- web_contents_->GetMutableRendererPrefs()->can_accept_load_drops = false;

+ intercepted_page_beforeunload_(false) {

// Set up delegate, so we get fully-functional window immediately.

// It will not appear in UI though until |load_state_ == kLoadCompleted|.

- web_contents_->SetDelegate(this);

- web_contents_->GetController().LoadURL(url, content::Referrer(),

- content::PAGE_TRANSITION_AUTO_TOPLEVEL, std::string());

- frontend_host_.reset(content::DevToolsClientHost::CreateDevToolsFrontendHost(

- web_contents_, this));

- file_helper_.reset(new DevToolsFileHelper(web_contents_, profile));

- file_system_indexer_ = new DevToolsFileSystemIndexer();

- extensions::ChromeExtensionWebContentsObserver::CreateForWebContents(

- web_contents_);

+ web_contents()->SetDelegate(this);

g_instances.Get().push_back(this);

- // Wipe out page icon so that the default application icon is used.

- content::NavigationEntry* entry =

- web_contents_->GetController().GetActiveEntry();

- entry->GetFavicon().image = gfx::Image();

- entry->GetFavicon().valid = true;

- // Register on-load actions.

- registrar_.Add(

- this, chrome::NOTIFICATION_BROWSER_THEME_CHANGED,

- content::Source<ThemeService>(

- ThemeServiceFactory::GetForProfile(profile_)));

// There is no inspected_rvh in case of shared workers.

if (inspected_rvh)

inspected_contents_observer_.reset(new InspectedWebContentsObserver(

content::WebContents::FromRenderViewHost(inspected_rvh)));

- embedder_message_dispatcher_.reset(

- DevToolsEmbedderMessageDispatcher::createForDevToolsFrontend(this));

event_forwarder_.reset(new DevToolsEventForwarder(this));

}

@@ -851,7 +630,7 @@ DevToolsWindow* DevToolsWindow::Create(

// Check for a place to dock.

Browser* browser = NULL;

int tab;

- content::WebContents* inspected_web_contents =

+ WebContents* inspected_web_contents =

content::WebContents::FromRenderViewHost(inspected_rvh);

if (!FindInspectedBrowserAndTabIndex(inspected_web_contents,

&browser, &tab) ||

@@ -875,31 +654,17 @@ GURL DevToolsWindow::GetDevToolsURL(Profile* profile,

bool shared_worker_frontend,

bool external_frontend,

bool can_dock) {

- if (base_url.SchemeIs("data"))

Vladislav Kaznacheev 2014/04/29 11:10:05 Why remove this? This has been added in https://co

pfeldman 2014/04/29 11:28:11 It is good we have you remembering it. How about a

- return base_url;

std::string frontend_url(

base_url.is_empty() ? chrome::kChromeUIDevToolsURL : base_url.spec());

- ThemeService* tp = ThemeServiceFactory::GetForProfile(profile);

- DCHECK(tp);

std::string url_string(

frontend_url +

- ((frontend_url.find("?") == std::string::npos) ? "?" : "&") +

- "dockSide=undocked" + // TODO(dgozman): remove this support in M38.

- "&toolbarColor=" +

- SkColorToRGBAString(tp->GetColor(ThemeProperties::COLOR_TOOLBAR)) +

- "&textColor=" +

- SkColorToRGBAString(tp->GetColor(ThemeProperties::COLOR_BOOKMARK_TEXT)));

+ ((frontend_url.find("?") == std::string::npos) ? "?" : "&"));

if (shared_worker_frontend)

url_string += "&isSharedWorker=true";

if (external_frontend)

url_string += "&remoteFrontend=true";

if (can_dock)

url_string += "&can_dock=true";

- if (CommandLine::ForCurrentProcess()->HasSwitch(

- switches::kEnableDevToolsExperiments))

- url_string += "&experiments=true";

- url_string += "&updateAppcache";

return GURL(url_string);

}

@@ -910,7 +675,7 @@ DevToolsWindow* DevToolsWindow::FindDevToolsWindow(

content::DevToolsManager* manager = content::DevToolsManager::GetInstance();

for (DevToolsWindows::iterator it(instances->begin()); it != instances->end();

++it) {

- if (manager->GetDevToolsAgentHostFor((*it)->frontend_host_.get()) ==

+ if (manager->GetDevToolsAgentHostFor((*it)->frontend_host()) ==

agent_host)

return *it;

}

@@ -925,50 +690,60 @@ DevToolsWindow* DevToolsWindow::AsDevToolsWindow(

DevToolsWindows* instances = g_instances.Pointer();

for (DevToolsWindows::iterator it(instances->begin()); it != instances->end();

++it) {

- if ((*it)->web_contents_->GetRenderViewHost() == window_rvh)

+ if ((*it)->web_contents()->GetRenderViewHost() == window_rvh)

return *it;

}

return NULL;

}

-void DevToolsWindow::Observe(int type,

- const content::NotificationSource& source,

- const content::NotificationDetails& details) {

- DCHECK_EQ(chrome::NOTIFICATION_BROWSER_THEME_CHANGED, type);

- UpdateTheme();

+void DevToolsWindow::InspectedContentsClosing() {

+ intercepted_page_beforeunload_ = false;

+ // This will prevent any activity after frontend is loaded.

+ action_on_load_ = DevToolsToggleAction::NoOp();

+ ignore_set_is_docked_ = true;

+ DevToolsWindowBase::InspectedContentsClosing();

}

-content::WebContents* DevToolsWindow::OpenURLFromTab(

- content::WebContents* source,

+WebContents* DevToolsWindow::OpenURLFromTab(

+ WebContents* source,

const content::OpenURLParams& params) {

- DCHECK(source == web_contents_);

+ DCHECK(source == web_contents());

if (!params.url.SchemeIs(content::kChromeDevToolsScheme)) {

- content::WebContents* inspected_web_contents = GetInspectedWebContents();

+ WebContents* inspected_web_contents = GetInspectedWebContents();

return inspected_web_contents ?

inspected_web_contents->OpenURL(params) : NULL;

}

content::DevToolsManager* manager = content::DevToolsManager::GetInstance();

scoped_refptr<DevToolsAgentHost> agent_host(

- manager->GetDevToolsAgentHostFor(frontend_host_.get()));

+ manager->GetDevToolsAgentHostFor(frontend_host()));

if (!agent_host.get())

return NULL;

- manager->ClientHostClosing(frontend_host_.get());

+ manager->ClientHostClosing(frontend_host());

manager->RegisterDevToolsClientHostFor(agent_host.get(),

- frontend_host_.get());

+ frontend_host());

content::NavigationController::LoadURLParams load_url_params(params.url);

- web_contents_->GetController().LoadURLWithParams(load_url_params);

- return web_contents_;

+ web_contents()->GetController().LoadURLWithParams(load_url_params);

+ return web_contents();

+void DevToolsWindow::ActivateContents(WebContents* contents) {

+ if (is_docked_) {

+ WebContents* inspected_tab = this->GetInspectedWebContents();

Vladislav Kaznacheev 2014/04/29 11:10:05 How does explicit 'this' help us here?

pfeldman 2014/04/29 11:28:11 This code just moved - for some reason it was defi

+ inspected_tab->GetDelegate()->ActivateContents(inspected_tab);

+ } else {

+ browser_->window()->Activate();

+ }

}

-void DevToolsWindow::AddNewContents(content::WebContents* source,

- content::WebContents* new_contents,

+void DevToolsWindow::AddNewContents(WebContents* source,

+ WebContents* new_contents,

WindowOpenDisposition disposition,

const gfx::Rect& initial_pos,

bool user_gesture,

bool* was_blocked) {

- content::WebContents* inspected_web_contents = GetInspectedWebContents();

+ WebContents* inspected_web_contents = GetInspectedWebContents();

if (inspected_web_contents) {

inspected_web_contents->GetDelegate()->AddNewContents(

source, new_contents, disposition, initial_pos, user_gesture,

@@ -976,7 +751,7 @@ void DevToolsWindow::AddNewContents(content::WebContents* source,

}

-void DevToolsWindow::CloseContents(content::WebContents* source) {

+void DevToolsWindow::CloseContents(WebContents* source) {

CHECK(is_docked_);

// This will prevent any activity after frontend is loaded.

action_on_load_ = DevToolsToggleAction::NoOp();

@@ -985,10 +760,10 @@ void DevToolsWindow::CloseContents(content::WebContents* source) {

BrowserWindow* inspected_window = GetInspectedBrowserWindow();

if (inspected_window)

inspected_window->UpdateDevTools();

- // In case of docked web_contents_, we own it so delete here.

+ // In case of docked web_contents(), we own it so delete here.

// Embedding DevTools window will be deleted as a result of

// WebContentsDestroyed callback.

- delete web_contents_;

+ delete web_contents();

}

void DevToolsWindow::ContentsZoomChange(bool zoom_in) {

@@ -997,19 +772,19 @@ void DevToolsWindow::ContentsZoomChange(bool zoom_in) {

zoom_in ? content::PAGE_ZOOM_IN : content::PAGE_ZOOM_OUT);

}

-void DevToolsWindow::BeforeUnloadFired(content::WebContents* tab,

+void DevToolsWindow::BeforeUnloadFired(WebContents* tab,

bool proceed,

bool* proceed_to_fire_unload) {

if (!intercepted_page_beforeunload_) {

// Docked devtools window closed directly.

if (proceed) {

content::DevToolsManager::GetInstance()->ClientHostClosing(

- frontend_host_.get());

+ frontend_host());

}

*proceed_to_fire_unload = proceed;

} else {

// Inspected page is attempting to close.

- content::WebContents* inspected_web_contents = GetInspectedWebContents();

+ WebContents* inspected_web_contents = GetInspectedWebContents();

if (proceed) {

inspected_web_contents->DispatchBeforeUnload(false);

} else {

@@ -1023,7 +798,7 @@ void DevToolsWindow::BeforeUnloadFired(content::WebContents* tab,

}

bool DevToolsWindow::PreHandleKeyboardEvent(

- content::WebContents* source,

+ WebContents* source,

const content::NativeWebKeyboardEvent& event,

bool* is_keyboard_shortcut) {

if (is_docked_) {

@@ -1037,7 +812,7 @@ bool DevToolsWindow::PreHandleKeyboardEvent(

}

void DevToolsWindow::HandleKeyboardEvent(

- content::WebContents* source,

+ WebContents* source,

const content::NativeWebKeyboardEvent& event) {

if (is_docked_) {

if (event.windowsKeyCode == 0x08) {

@@ -1051,25 +826,25 @@ void DevToolsWindow::HandleKeyboardEvent(

}

content::JavaScriptDialogManager* DevToolsWindow::GetJavaScriptDialogManager() {

- content::WebContents* inspected_web_contents = GetInspectedWebContents();

+ WebContents* inspected_web_contents = GetInspectedWebContents();

return (inspected_web_contents && inspected_web_contents->GetDelegate()) ?

inspected_web_contents->GetDelegate()->GetJavaScriptDialogManager() :

content::WebContentsDelegate::GetJavaScriptDialogManager();

}

content::ColorChooser* DevToolsWindow::OpenColorChooser(

- content::WebContents* web_contents,

+ WebContents* web_contents,

SkColor initial_color,

const std::vector<content::ColorSuggestion>& suggestions) {

return chrome::ShowColorChooser(web_contents, initial_color);

}

-void DevToolsWindow::RunFileChooser(content::WebContents* web_contents,

+void DevToolsWindow::RunFileChooser(WebContents* web_contents,

const content::FileChooserParams& params) {

FileSelectHelper::RunFileChooser(web_contents, params);

}

-void DevToolsWindow::WebContentsFocused(content::WebContents* contents) {

+void DevToolsWindow::WebContentsFocused(WebContents* contents) {

Browser* inspected_browser = NULL;

int inspected_tab_index = -1;

if (is_docked_ && FindInspectedBrowserAndTabIndex(GetInspectedWebContents(),

@@ -1079,7 +854,7 @@ void DevToolsWindow::WebContentsFocused(content::WebContents* contents) {

}

bool DevToolsWindow::PreHandleGestureEvent(

dgozman 2014/04/29 11:32:26 This is DevToolsWindowBase functionality.

pfeldman 2014/04/29 11:37:12 It can't be - DevToolsWindowBase is not a WebConte

- content::WebContents* source,

+ WebContents* source,

const blink::WebGestureEvent& event) {

// Disable pinch zooming.

return event.type == blink::WebGestureEvent::GesturePinchBegin ||

@@ -1087,57 +862,19 @@ bool DevToolsWindow::PreHandleGestureEvent(

event.type == blink::WebGestureEvent::GesturePinchEnd;

}

-void DevToolsWindow::DispatchOnEmbedder(const std::string& message) {

- std::string method;

- base::ListValue empty_params;

- base::ListValue* params = &empty_params;

- base::DictionaryValue* dict = NULL;

- scoped_ptr<base::Value> parsed_message(base::JSONReader::Read(message));

- if (!parsed_message ||

- !parsed_message->GetAsDictionary(&dict) ||

- !dict->GetString(kFrontendHostMethod, &method) ||

- (dict->HasKey(kFrontendHostParams) &&

- !dict->GetList(kFrontendHostParams, &params))) {

- LOG(ERROR) << "Invalid message was sent to embedder: " << message;

- return;

- }

- int id = 0;

- dict->GetInteger(kFrontendHostId, &id);

- std::string error;

- embedder_message_dispatcher_->Dispatch(method, params, &error);

- if (id) {

- scoped_ptr<base::Value> id_value(base::Value::CreateIntegerValue(id));

- scoped_ptr<base::Value> error_value(base::Value::CreateStringValue(error));

- CallClientFunction("InspectorFrontendAPI.embedderMessageAck",

- id_value.get(), error_value.get(), NULL);

- }

void DevToolsWindow::ActivateWindow() {

dgozman 2014/04/29 11:32:26 Having this functionality for in-tab DevTools woul

pfeldman 2014/04/29 11:37:12 That's why it is implemented there.

if (is_docked_ && GetInspectedBrowserWindow())

- web_contents_->GetView()->Focus();

+ web_contents()->GetView()->Focus();

else if (!is_docked_ && !browser_->window()->IsActive())

browser_->window()->Activate();

}

-void DevToolsWindow::ActivateContents(content::WebContents* contents) {

- if (is_docked_) {

- content::WebContents* inspected_tab = this->GetInspectedWebContents();

- inspected_tab->GetDelegate()->ActivateContents(inspected_tab);

- } else {

- browser_->window()->Activate();

- }

void DevToolsWindow::CloseWindow() {

DCHECK(is_docked_);

// This will prevent any activity after frontend is loaded.

action_on_load_ = DevToolsToggleAction::NoOp();

ignore_set_is_docked_ = true;

- web_contents_->DispatchBeforeUnload(false);

+ web_contents()->DispatchBeforeUnload(false);

}

void DevToolsWindow::SetContentsInsets(

@@ -1222,7 +959,7 @@ void DevToolsWindow::SetIsDocked(bool dock_requested) {

// the browser object's close and delete. Remove observer first.

TabStripModel* tab_strip_model = browser_->tab_strip_model();

tab_strip_model->DetachWebContentsAt(

- tab_strip_model->GetIndexOfWebContents(web_contents_));

+ tab_strip_model->GetIndexOfWebContents(web_contents()));

browser_ = NULL;

} else if (!dock_requested && was_docked) {

// Update inspected window to hide split and reset it.

@@ -1238,7 +975,7 @@ void DevToolsWindow::OpenInNewTab(const std::string& url) {

content::OpenURLParams params(

GURL(url), content::Referrer(), NEW_FOREGROUND_TAB,

content::PAGE_TRANSITION_LINK, false);

- content::WebContents* inspected_web_contents = GetInspectedWebContents();

+ WebContents* inspected_web_contents = GetInspectedWebContents();

if (inspected_web_contents) {

inspected_web_contents->OpenURL(params);

} else {

@@ -1264,264 +1001,14 @@ void DevToolsWindow::OpenInNewTab(const std::string& url) {

}

-void DevToolsWindow::SaveToFile(const std::string& url,

- const std::string& content,

- bool save_as) {

- file_helper_->Save(url, content, save_as,

- base::Bind(&DevToolsWindow::FileSavedAs,

- weak_factory_.GetWeakPtr(), url),

- base::Bind(&DevToolsWindow::CanceledFileSaveAs,

- weak_factory_.GetWeakPtr(), url));

-void DevToolsWindow::AppendToFile(const std::string& url,

- const std::string& content) {

- file_helper_->Append(url, content,

- base::Bind(&DevToolsWindow::AppendedTo,

- weak_factory_.GetWeakPtr(), url));

-void DevToolsWindow::RequestFileSystems() {

- CHECK(web_contents_->GetURL().SchemeIs(content::kChromeDevToolsScheme));

- file_helper_->RequestFileSystems(base::Bind(

- &DevToolsWindow::FileSystemsLoaded, weak_factory_.GetWeakPtr()));

-void DevToolsWindow::AddFileSystem() {

- CHECK(web_contents_->GetURL().SchemeIs(content::kChromeDevToolsScheme));

- file_helper_->AddFileSystem(

- base::Bind(&DevToolsWindow::FileSystemAdded, weak_factory_.GetWeakPtr()),

- base::Bind(&DevToolsWindow::ShowDevToolsConfirmInfoBar,

- weak_factory_.GetWeakPtr()));

-void DevToolsWindow::RemoveFileSystem(const std::string& file_system_path) {

- CHECK(web_contents_->GetURL().SchemeIs(content::kChromeDevToolsScheme));

- file_helper_->RemoveFileSystem(file_system_path);

- base::StringValue file_system_path_value(file_system_path);

- CallClientFunction("InspectorFrontendAPI.fileSystemRemoved",

- &file_system_path_value, NULL, NULL);

-void DevToolsWindow::UpgradeDraggedFileSystemPermissions(

- const std::string& file_system_url) {

- CHECK(web_contents_->GetURL().SchemeIs(content::kChromeDevToolsScheme));

- file_helper_->UpgradeDraggedFileSystemPermissions(

- file_system_url,

- base::Bind(&DevToolsWindow::FileSystemAdded, weak_factory_.GetWeakPtr()),

- base::Bind(&DevToolsWindow::ShowDevToolsConfirmInfoBar,

- weak_factory_.GetWeakPtr()));

-void DevToolsWindow::IndexPath(int request_id,

- const std::string& file_system_path) {

- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

- CHECK(web_contents_->GetURL().SchemeIs(content::kChromeDevToolsScheme));

- if (!file_helper_->IsFileSystemAdded(file_system_path)) {

- IndexingDone(request_id, file_system_path);

- return;

- }

- indexing_jobs_[request_id] =

- scoped_refptr<DevToolsFileSystemIndexer::FileSystemIndexingJob>(

- file_system_indexer_->IndexPath(

- file_system_path,

- Bind(&DevToolsWindow::IndexingTotalWorkCalculated,

- weak_factory_.GetWeakPtr(),

- request_id,

- file_system_path),

- Bind(&DevToolsWindow::IndexingWorked,

- weak_factory_.GetWeakPtr(),

- request_id,

- file_system_path),

- Bind(&DevToolsWindow::IndexingDone,

- weak_factory_.GetWeakPtr(),

- request_id,

- file_system_path)));

-void DevToolsWindow::StopIndexing(int request_id) {

- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

- IndexingJobsMap::iterator it = indexing_jobs_.find(request_id);

- if (it == indexing_jobs_.end())

- return;

- it->second->Stop();

- indexing_jobs_.erase(it);

-void DevToolsWindow::SearchInPath(int request_id,

- const std::string& file_system_path,

- const std::string& query) {

- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

- CHECK(web_contents_->GetURL().SchemeIs(content::kChromeDevToolsScheme));

- if (!file_helper_->IsFileSystemAdded(file_system_path)) {

- SearchCompleted(request_id, file_system_path, std::vector<std::string>());

- return;

- }

- file_system_indexer_->SearchInPath(file_system_path,

- query,

- Bind(&DevToolsWindow::SearchCompleted,

- weak_factory_.GetWeakPtr(),

- request_id,

- file_system_path));

-void DevToolsWindow::ZoomIn() {

- chrome_page_zoom::Zoom(web_contents(), content::PAGE_ZOOM_IN);

-void DevToolsWindow::ZoomOut() {

- chrome_page_zoom::Zoom(web_contents(), content::PAGE_ZOOM_OUT);

-void DevToolsWindow::ResetZoom() {

- chrome_page_zoom::Zoom(web_contents(), content::PAGE_ZOOM_RESET);

-void DevToolsWindow::OpenUrlOnRemoteDeviceAndInspect(

- const std::string& browser_id,

- const std::string& url) {

- if (remote_targets_handler_)

- remote_targets_handler_->OpenAndInspect(browser_id, url, profile_);

-void DevToolsWindow::StartRemoteDevicesListener() {

- remote_targets_handler_ = DevToolsRemoteTargetsUIHandler::CreateForAdb(

- base::Bind(&DevToolsWindow::PopulateRemoteDevices,

- base::Unretained(this)),

- profile_);

-void DevToolsWindow::StopRemoteDevicesListener() {

- remote_targets_handler_.reset();

-void DevToolsWindow::EnableRemoteDeviceCounter(bool enable) {

- DevToolsAndroidBridge* adb_bridge =

- DevToolsAndroidBridge::Factory::GetForProfile(profile_);

- if (!adb_bridge)

- return;

- DCHECK(device_listener_enabled_ != enable);

- device_listener_enabled_ = enable;

- if (enable)

- adb_bridge->AddDeviceCountListener(this);

- else

- adb_bridge->RemoveDeviceCountListener(this);

-void DevToolsWindow::DeviceCountChanged(int count) {

- base::FundamentalValue value(count);

- CallClientFunction(

- "InspectorFrontendAPI.setRemoteDeviceCount", &value, NULL, NULL);

-void DevToolsWindow::PopulateRemoteDevices(

- const std::string& source,

- scoped_ptr<base::ListValue> targets) {

- CallClientFunction(

- "InspectorFrontendAPI.populateRemoteDevices", targets.get(), NULL, NULL);

-void DevToolsWindow::FileSavedAs(const std::string& url) {

- base::StringValue url_value(url);

- CallClientFunction("InspectorFrontendAPI.savedURL", &url_value, NULL, NULL);

-void DevToolsWindow::CanceledFileSaveAs(const std::string& url) {

- base::StringValue url_value(url);

- CallClientFunction("InspectorFrontendAPI.canceledSaveURL",

- &url_value, NULL, NULL);

-void DevToolsWindow::AppendedTo(const std::string& url) {

- base::StringValue url_value(url);

- CallClientFunction("InspectorFrontendAPI.appendedToURL", &url_value, NULL,

- NULL);

-void DevToolsWindow::FileSystemsLoaded(

- const std::vector<DevToolsFileHelper::FileSystem>& file_systems) {

- base::ListValue file_systems_value;

- for (size_t i = 0; i < file_systems.size(); ++i)

- file_systems_value.Append(CreateFileSystemValue(file_systems[i]));

- CallClientFunction("InspectorFrontendAPI.fileSystemsLoaded",

- &file_systems_value, NULL, NULL);

-void DevToolsWindow::FileSystemAdded(

- const DevToolsFileHelper::FileSystem& file_system) {

- scoped_ptr<base::StringValue> error_string_value(

- new base::StringValue(std::string()));

- scoped_ptr<base::DictionaryValue> file_system_value;

- if (!file_system.file_system_path.empty())

- file_system_value.reset(CreateFileSystemValue(file_system));

- CallClientFunction("InspectorFrontendAPI.fileSystemAdded",

- error_string_value.get(), file_system_value.get(), NULL);

-void DevToolsWindow::IndexingTotalWorkCalculated(

- int request_id,

- const std::string& file_system_path,

- int total_work) {

- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

- base::FundamentalValue request_id_value(request_id);

- base::StringValue file_system_path_value(file_system_path);

- base::FundamentalValue total_work_value(total_work);

- CallClientFunction("InspectorFrontendAPI.indexingTotalWorkCalculated",

- &request_id_value, &file_system_path_value,

- &total_work_value);

-void DevToolsWindow::IndexingWorked(int request_id,

- const std::string& file_system_path,

- int worked) {

- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

- base::FundamentalValue request_id_value(request_id);

- base::StringValue file_system_path_value(file_system_path);

- base::FundamentalValue worked_value(worked);

- CallClientFunction("InspectorFrontendAPI.indexingWorked", &request_id_value,

- &file_system_path_value, &worked_value);

-void DevToolsWindow::IndexingDone(int request_id,

- const std::string& file_system_path) {

- indexing_jobs_.erase(request_id);

- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

- base::FundamentalValue request_id_value(request_id);

- base::StringValue file_system_path_value(file_system_path);

- CallClientFunction("InspectorFrontendAPI.indexingDone", &request_id_value,

- &file_system_path_value, NULL);

-void DevToolsWindow::SearchCompleted(

- int request_id,

- const std::string& file_system_path,

- const std::vector<std::string>& file_paths) {

- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

- base::ListValue file_paths_value;

- for (std::vector<std::string>::const_iterator it(file_paths.begin());

- it != file_paths.end(); ++it) {

- file_paths_value.AppendString(*it);

- }

- base::FundamentalValue request_id_value(request_id);

- base::StringValue file_system_path_value(file_system_path);

- CallClientFunction("InspectorFrontendAPI.searchCompleted", &request_id_value,

- &file_system_path_value, &file_paths_value);

-void DevToolsWindow::ShowDevToolsConfirmInfoBar(

- const base::string16& message,

- const InfoBarCallback& callback) {

- DevToolsConfirmInfoBarDelegate::Create(

- is_docked_ ?

- InfoBarService::FromWebContents(GetInspectedWebContents()) :

- InfoBarService::FromWebContents(web_contents_),

- callback, message);

+void DevToolsWindow::SetWhitelistedShortcuts(

+ const std::string& message) {

+ event_forwarder_->SetWhitelistedShortcuts(message);

}

void DevToolsWindow::CreateDevToolsBrowser() {

std::string wp_key = GetDevToolsWindowPlacementPrefKey();

- PrefService* prefs = profile_->GetPrefs();

+ PrefService* prefs = profile()->GetPrefs();

const base::DictionaryValue* wp_pref = prefs->GetDictionary(wp_key.c_str());

if (!wp_pref || wp_pref->empty()) {

DictionaryPrefUpdate update(prefs, wp_key.c_str());

@@ -1535,18 +1022,18 @@ void DevToolsWindow::CreateDevToolsBrowser() {

}

browser_ = new Browser(Browser::CreateParams::CreateForDevTools(

- profile_,

+ profile(),

chrome::GetHostDesktopTypeForNativeView(

- web_contents_->GetView()->GetNativeView())));

+ web_contents()->GetView()->GetNativeView())));

browser_->tab_strip_model()->AddWebContents(

- web_contents_, -1, content::PAGE_TRANSITION_AUTO_TOPLEVEL,

+ web_contents(), -1, content::PAGE_TRANSITION_AUTO_TOPLEVEL,

TabStripModel::ADD_ACTIVE);

- GetRenderViewHost()->SyncRendererPrefs();

+ web_contents()->GetRenderViewHost()->SyncRendererPrefs();

}

// static

bool DevToolsWindow::FindInspectedBrowserAndTabIndex(

- content::WebContents* inspected_web_contents, Browser** browser, int* tab) {

+ WebContents* inspected_web_contents, Browser** browser, int* tab) {

if (!inspected_web_contents)

return false;

@@ -1606,20 +1093,8 @@ void DevToolsWindow::DoAction(const DevToolsToggleAction& action) {

}

-void DevToolsWindow::UpdateTheme() {

- ThemeService* tp = ThemeServiceFactory::GetForProfile(profile_);

- DCHECK(tp);

- std::string command("InspectorFrontendAPI.setToolbarColors(\"" +

- SkColorToRGBAString(tp->GetColor(ThemeProperties::COLOR_TOOLBAR)) +

- "\", \"" +

- SkColorToRGBAString(tp->GetColor(ThemeProperties::COLOR_BOOKMARK_TEXT)) +

- "\")");

- web_contents_->GetMainFrame()->ExecuteJavaScript(base::ASCIIToUTF16(command));

void DevToolsWindow::AddDevToolsExtensionsToClient() {

- content::WebContents* inspected_web_contents = GetInspectedWebContents();

+ WebContents* inspected_web_contents = GetInspectedWebContents();

if (inspected_web_contents) {

SessionTabHelper* session_tab_helper =

SessionTabHelper::FromWebContents(inspected_web_contents);

@@ -1628,56 +1103,7 @@ void DevToolsWindow::AddDevToolsExtensionsToClient() {

CallClientFunction("WebInspector.setInspectedTabId", &tabId, NULL, NULL);

}

- Profile* profile =

- Profile::FromBrowserContext(web_contents_->GetBrowserContext());

- const ExtensionService* extension_service = extensions::ExtensionSystem::Get(

- profile->GetOriginalProfile())->extension_service();

- if (!extension_service)

- return;

- const extensions::ExtensionSet* extensions = extension_service->extensions();

- base::ListValue results;

- for (extensions::ExtensionSet::const_iterator extension(extensions->begin());

- extension != extensions->end(); ++extension) {

- if (extensions::ManifestURL::GetDevToolsPage(extension->get()).is_empty())

- continue;

- base::DictionaryValue* extension_info = new base::DictionaryValue();

- extension_info->Set(

- "startPage",

- new base::StringValue(

- extensions::ManifestURL::GetDevToolsPage(extension->get()).spec()));

- extension_info->Set("name", new base::StringValue((*extension)->name()));

- extension_info->Set(

- "exposeExperimentalAPIs",

- new base::FundamentalValue((*extension)->HasAPIPermission(

- extensions::APIPermission::kExperimental)));

- results.Append(extension_info);

- }

- CallClientFunction("WebInspector.addExtensions", &results, NULL, NULL);

-void DevToolsWindow::CallClientFunction(const std::string& function_name,

- const base::Value* arg1,

- const base::Value* arg2,

- const base::Value* arg3) {

- std::string params;

- if (arg1) {

- std::string json;

- base::JSONWriter::Write(arg1, &json);

- params.append(json);

- if (arg2) {

- base::JSONWriter::Write(arg2, &json);

- params.append(", " + json);

- if (arg3) {

- base::JSONWriter::Write(arg3, &json);

- params.append(", " + json);

- }

- base::string16 javascript =

- base::UTF8ToUTF16(function_name + "(" + params + ");");

- web_contents_->GetMainFrame()->ExecuteJavaScript(javascript);

+ DevToolsWindowBase::AddDevToolsExtensionsToClient();

}

void DevToolsWindow::UpdateBrowserToolbar() {

@@ -1686,12 +1112,13 @@ void DevToolsWindow::UpdateBrowserToolbar() {

inspected_window->UpdateToolbar(NULL);

}

-content::WebContents* DevToolsWindow::GetInspectedWebContents() {

+WebContents* DevToolsWindow::GetInspectedWebContents() {

return inspected_contents_observer_ ?

inspected_contents_observer_->web_contents() : NULL;

}

void DevToolsWindow::DocumentOnLoadCompletedInMainFrame() {

+ DevToolsWindowBase::DocumentOnLoadCompletedInMainFrame();

// We could be in kLoadCompleted state already if frontend reloads itself.

if (load_state_ != kLoadCompleted) {

// Load is completed when both kIsDockedSet and kOnLoadFired happened.

@@ -1705,8 +1132,6 @@ void DevToolsWindow::DocumentOnLoadCompletedInMainFrame() {

void DevToolsWindow::LoadCompleted() {

Show(action_on_load_);

action_on_load_ = DevToolsToggleAction::NoOp();

- UpdateTheme();

- AddDevToolsExtensionsToClient();

if (!load_completed_callback_.is_null()) {

load_completed_callback_.Run();

load_completed_callback_ = base::Closure();

@@ -1722,11 +1147,6 @@ void DevToolsWindow::SetLoadCompletedCallback(const base::Closure& closure) {

load_completed_callback_ = closure;

}

-void DevToolsWindow::SetWhitelistedShortcuts(

- const std::string& message) {

- event_forwarder_->SetWhitelistedShortcuts(message);

bool DevToolsWindow::ForwardKeyboardEvent(

const content::NativeWebKeyboardEvent& event) {

return event_forwarder_->ForwardEvent(event);