[DevTools] Remote JSON requests from javascript (Chromium side)

chrome/browser/devtools/devtools_ui_bindings.cc

 // Copyright 2014 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/devtools/devtools_ui_bindings.h"
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
@@ skipping 29 matching lines @@
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/renderer_preferences.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/permissions/permissions_data.h"
+#include "net/base/net_errors.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/page_transition_types.h"
 
 using base::DictionaryValue;
 using content::BrowserThread;
 
 namespace content {
 struct LoadCommittedDetails;
 struct FrameNavigateParams;
 }
@@ skipping 36 matching lines @@
   return file_system_value;
 }
 
 Browser* FindBrowser(content::WebContents* web_contents) {
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     int tab_index = it->tab_strip_model()->GetIndexOfWebContents(
         web_contents);
     if (tab_index != TabStripModel::kNoTab)
       return *it;
   }
-  return NULL;
+  return nullptr;
 }
 
 // DevToolsConfirmInfoBarDelegate ---------------------------------------------
 
 typedef base::Callback<void(bool)> InfoBarCallback;
 
 class DevToolsConfirmInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
-  // If |infobar_service| is NULL, runs |callback| with a single argument with
+  // 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 InfoBarCallback& callback,
                      const base::string16& message);
 
  private:
   DevToolsConfirmInfoBarDelegate(
       const InfoBarCallback& callback,
       const base::string16& message);
@@ skipping 179 matching lines @@
 void DevToolsUIBindings::FrontendWebContentsObserver::
     DidNavigateMainFrame(const content::LoadCommittedDetails& details,
                          const content::FrameNavigateParams& params) {
   devtools_bindings_->DidNavigateMainFrame();
 }
 
 // DevToolsUIBindings ---------------------------------------------------------
 
 DevToolsUIBindings* DevToolsUIBindings::ForWebContents(
      content::WebContents* web_contents) {
- if (g_instances == NULL)
-   return NULL;
+ if (g_instances == nullptr)
+   return nullptr;
  DevToolsUIBindingsList* instances = g_instances.Pointer();
- for (DevToolsUIBindingsList::iterator it(instances->begin());
-      it != instances->end(); ++it) {
-   if ((*it)->web_contents() == web_contents)
-     return *it;
+ for (DevToolsUIBindings* bindings : *instances) {
+   if (bindings->web_contents() == web_contents)
+     return bindings;
  }
- return NULL;
+ return nullptr;
 }
 
 // static
 GURL DevToolsUIBindings::ApplyThemeToURL(Profile* profile,
                                          const GURL& base_url) {
   std::string frontend_url = base_url.spec();
   ThemeService* tp = ThemeServiceFactory::GetForProfile(profile);
   DCHECK(tp);
   std::string url_string(
       frontend_url +
@@ skipping 35 matching lines @@
   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_)));
 
   embedder_message_dispatcher_.reset(
-      DevToolsEmbedderMessageDispatcher::createForDevToolsFrontend(this));
+      DevToolsEmbedderMessageDispatcher::CreateForDevToolsFrontend(this));
 
   frontend_host_.reset(content::DevToolsFrontendHost::Create(
       web_contents_->GetMainFrame(), this));
 }
 
 DevToolsUIBindings::~DevToolsUIBindings() {
   if (agent_host_.get())
     agent_host_->DetachClient();
 
-  for (IndexingJobsMap::const_iterator jobs_it(indexing_jobs_.begin());
-       jobs_it != indexing_jobs_.end(); ++jobs_it) {
-    jobs_it->second->Stop();
+  for (const auto& job : indexing_jobs_) {
+    job.second->Stop();
   }
   indexing_jobs_.clear();
-  SetDeviceCountUpdatesEnabled(false);
-  SetDevicesUpdatesEnabled(false);
+  SetDeviceCountUpdatesEnabled(0, false);
+  SetDevicesUpdatesEnabled(0, false);
 
   // Remove self from global list.
   DevToolsUIBindingsList* instances = g_instances.Pointer();
   DevToolsUIBindingsList::iterator it(
       std::find(instances->begin(), instances->end(), this));
   DCHECK(it != instances->end());
   instances->erase(it);
 }
 
 // content::NotificationObserver overrides ------------------------------------
 void DevToolsUIBindings::Observe(int type,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_BROWSER_THEME_CHANGED, type);
   UpdateTheme();
 }
 
 // content::DevToolsFrontendHost::Delegate implementation ---------------------
 void DevToolsUIBindings::HandleMessageFromDevToolsFrontend(
     const std::string& message) {
   std::string method;
   base::ListValue empty_params;
   base::ListValue* params = &empty_params;
 
-  base::DictionaryValue* dict = NULL;
+  base::DictionaryValue* dict = nullptr;
   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) {
-    base::FundamentalValue id_value(id);
-    base::StringValue error_value(error);
-    CallClientFunction("DevToolsAPI.embedderMessageAck",
-                       &id_value, &error_value, NULL);
-  }
+  embedder_message_dispatcher_->Dispatch(id, method, params);
 }
 
 void DevToolsUIBindings::HandleMessageFromDevToolsFrontendToBackend(
     const std::string& message) {
   if (agent_host_.get())
     agent_host_->DispatchProtocolMessage(message);
 }
 
 // content::DevToolsAgentHostClient implementation --------------------------
 void DevToolsUIBindings::DispatchProtocolMessage(
     content::DevToolsAgentHost* agent_host, const std::string& message) {
   DCHECK(agent_host == agent_host_.get());
 
   if (message.length() < kMaxMessageChunkSize) {
     base::string16 javascript = base::UTF8ToUTF16(
         "DevToolsAPI.dispatchMessage(" + message + ");");
     web_contents_->GetMainFrame()->ExecuteJavaScript(javascript);
     return;
   }
 
   base::FundamentalValue total_size(static_cast<int>(message.length()));
   for (size_t pos = 0; pos < message.length(); pos += kMaxMessageChunkSize) {
     base::StringValue message_value(message.substr(pos, kMaxMessageChunkSize));
     CallClientFunction("DevToolsAPI.dispatchMessageChunk",
-                       &message_value, pos ? NULL : &total_size, NULL);
+                       &message_value, pos ? nullptr : &total_size, nullptr);
   }
 }
 
 void DevToolsUIBindings::AgentHostClosed(
     content::DevToolsAgentHost* agent_host,
     bool replaced_with_another_client) {
   DCHECK(agent_host == agent_host_.get());
-  agent_host_ = NULL;
+  agent_host_ = nullptr;
   delegate_->InspectedContentsClosing();
 }
 
 // DevToolsEmbedderMessageDispatcher::Delegate implementation -----------------
-void DevToolsUIBindings::ActivateWindow() {
+void DevToolsUIBindings::ActivateWindow(int request_id) {
   delegate_->ActivateWindow();
 }
 
-void DevToolsUIBindings::CloseWindow() {
+void DevToolsUIBindings::CloseWindow(int request_id) {
   delegate_->CloseWindow();
 }
 
-void DevToolsUIBindings::LoadCompleted() {
+void DevToolsUIBindings::LoadCompleted(int request_id) {
   FrontendLoaded();
 }
 
-void DevToolsUIBindings::SetInspectedPageBounds(const gfx::Rect& rect) {
+void DevToolsUIBindings::SetInspectedPageBounds(int request_id,
+                                                const gfx::Rect& rect) {
   delegate_->SetInspectedPageBounds(rect);
 }
 
-void DevToolsUIBindings::SetIsDocked(bool dock_requested) {
+void DevToolsUIBindings::SetIsDocked(int request_id, bool dock_requested) {
   delegate_->SetIsDocked(dock_requested);
+  base::FundamentalValue id_value(request_id);
+  CallClientFunction("DevToolsAPI.embedderMessageAck",

[dgozman, 2015/02/12 10:20:36]

You should make a separate function for this, e.g. |SendEmbedderMessageAck|.

[vkuzkokov, 2015/02/27 14:00:05]

Done.

+                     &id_value, nullptr, nullptr);
 }
 
-void DevToolsUIBindings::InspectElementCompleted() {
+void DevToolsUIBindings::InspectElementCompleted(int request_id) {
   delegate_->InspectElementCompleted();
 }
 
-void DevToolsUIBindings::InspectedURLChanged(const std::string& url) {
+void DevToolsUIBindings::InspectedURLChanged(int request_id,
+                                             const std::string& url) {
   content::NavigationController& controller = web_contents()->GetController();
   content::NavigationEntry* entry = controller.GetActiveEntry();
   // DevTools UI is not localized.
   entry->SetTitle(
       base::UTF8ToUTF16(base::StringPrintf(kTitleFormat, url.c_str())));
   web_contents()->NotifyNavigationStateChanged(content::INVALIDATE_TYPE_TITLE);
 }
 
-void DevToolsUIBindings::OpenInNewTab(const std::string& url) {
+void DevToolsUIBindings::OpenInNewTab(int request_id, const std::string& url) {
   delegate_->OpenInNewTab(url);
 }
 
-void DevToolsUIBindings::SaveToFile(const std::string& url,
+void DevToolsUIBindings::SaveToFile(int request_id,
+                                    const std::string& url,
                                     const std::string& content,
                                     bool save_as) {
   file_helper_->Save(url, content, save_as,
                      base::Bind(&DevToolsUIBindings::FileSavedAs,
                                 weak_factory_.GetWeakPtr(), url),
                      base::Bind(&DevToolsUIBindings::CanceledFileSaveAs,
                                 weak_factory_.GetWeakPtr(), url));
 }
 
-void DevToolsUIBindings::AppendToFile(const std::string& url,
+void DevToolsUIBindings::AppendToFile(int request_id,
+                                      const std::string& url,
                                       const std::string& content) {
   file_helper_->Append(url, content,
                        base::Bind(&DevToolsUIBindings::AppendedTo,
                                   weak_factory_.GetWeakPtr(), url));
 }
 
-void DevToolsUIBindings::RequestFileSystems() {
+void DevToolsUIBindings::RequestFileSystems(int request_id) {
   CHECK(web_contents_->GetURL().SchemeIs(content::kChromeDevToolsScheme));
   file_helper_->RequestFileSystems(base::Bind(
       &DevToolsUIBindings::FileSystemsLoaded, weak_factory_.GetWeakPtr()));
 }
 
-void DevToolsUIBindings::AddFileSystem() {
+void DevToolsUIBindings::AddFileSystem(int request_id) {
   CHECK(web_contents_->GetURL().SchemeIs(content::kChromeDevToolsScheme));
   file_helper_->AddFileSystem(
       base::Bind(&DevToolsUIBindings::FileSystemAdded,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&DevToolsUIBindings::ShowDevToolsConfirmInfoBar,
                  weak_factory_.GetWeakPtr()));
 }
 
-void DevToolsUIBindings::RemoveFileSystem(
-    const std::string& file_system_path) {
+void DevToolsUIBindings::RemoveFileSystem(int request_id,
+                                          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("DevToolsAPI.fileSystemRemoved",
-                     &file_system_path_value, NULL, NULL);
+                     &file_system_path_value, nullptr, nullptr);
 }
 
 void DevToolsUIBindings::UpgradeDraggedFileSystemPermissions(
+    int request_id,
     const std::string& file_system_url) {
   CHECK(web_contents_->GetURL().SchemeIs(content::kChromeDevToolsScheme));
   file_helper_->UpgradeDraggedFileSystemPermissions(
       file_system_url,
       base::Bind(&DevToolsUIBindings::FileSystemAdded,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&DevToolsUIBindings::ShowDevToolsConfirmInfoBar,
                  weak_factory_.GetWeakPtr()));
 }
 
 void DevToolsUIBindings::IndexPath(int request_id,
+                                   int index_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);
+    IndexingDone(index_request_id, file_system_path);
     return;
   }
-  indexing_jobs_[request_id] =
+  indexing_jobs_[index_request_id] =
       scoped_refptr<DevToolsFileSystemIndexer::FileSystemIndexingJob>(
           file_system_indexer_->IndexPath(
               file_system_path,
               Bind(&DevToolsUIBindings::IndexingTotalWorkCalculated,
                    weak_factory_.GetWeakPtr(),
-                   request_id,
+                   index_request_id,
                    file_system_path),
               Bind(&DevToolsUIBindings::IndexingWorked,
                    weak_factory_.GetWeakPtr(),
-                   request_id,
+                   index_request_id,
                    file_system_path),
               Bind(&DevToolsUIBindings::IndexingDone,
                    weak_factory_.GetWeakPtr(),
-                   request_id,
+                   index_request_id,
                    file_system_path)));
 }
 
-void DevToolsUIBindings::StopIndexing(int request_id) {
+void DevToolsUIBindings::StopIndexing(int request_id, int index_request_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  IndexingJobsMap::iterator it = indexing_jobs_.find(request_id);
+  IndexingJobsMap::iterator it = indexing_jobs_.find(index_request_id);
   if (it == indexing_jobs_.end())
     return;
   it->second->Stop();
   indexing_jobs_.erase(it);
 }
 
 void DevToolsUIBindings::SearchInPath(int request_id,
+                                      int search_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>());
+    SearchCompleted(search_request_id,
+                    file_system_path,
+                    std::vector<std::string>());
     return;
   }
   file_system_indexer_->SearchInPath(file_system_path,
                                      query,
                                      Bind(&DevToolsUIBindings::SearchCompleted,
                                           weak_factory_.GetWeakPtr(),
-                                          request_id,
+                                          search_request_id,
                                           file_system_path));
 }
 
-void DevToolsUIBindings::SetWhitelistedShortcuts(
-    const std::string& message) {
+void DevToolsUIBindings::SetWhitelistedShortcuts(int request_id,
+                                                 const std::string& message) {
   delegate_->SetWhitelistedShortcuts(message);
 }
 
-void DevToolsUIBindings::ZoomIn() {
+void DevToolsUIBindings::ZoomIn(int request_id) {
   ui_zoom::PageZoom::Zoom(web_contents(), content::PAGE_ZOOM_IN);
 }
 
-void DevToolsUIBindings::ZoomOut() {
+void DevToolsUIBindings::ZoomOut(int request_id) {
   ui_zoom::PageZoom::Zoom(web_contents(), content::PAGE_ZOOM_OUT);
 }
 
-void DevToolsUIBindings::ResetZoom() {
+void DevToolsUIBindings::ResetZoom(int request_id) {
   ui_zoom::PageZoom::Zoom(web_contents(), content::PAGE_ZOOM_RESET);
 }
 
 static void InspectTarget(Profile* profile, DevToolsTargetImpl* target) {
   if (target)
     target->Inspect(profile);
 }
 
 void DevToolsUIBindings::OpenUrlOnRemoteDeviceAndInspect(
+    int request_id,
     const std::string& browser_id,
     const std::string& url) {
   if (remote_targets_handler_) {
     remote_targets_handler_->Open(browser_id, url,
         base::Bind(&InspectTarget, profile_));
   }
 }
 
-void DevToolsUIBindings::SetDeviceCountUpdatesEnabled(bool enabled) {
+void DevToolsUIBindings::SetDeviceCountUpdatesEnabled(int request_id,
+                                                      bool enabled) {
   if (device_count_updates_enabled_ == enabled)
     return;
   DevToolsAndroidBridge* adb_bridge =
       DevToolsAndroidBridge::Factory::GetForProfile(profile_);
   if (!adb_bridge)
     return;
 
   device_count_updates_enabled_ = enabled;
   if (enabled)
     adb_bridge->AddDeviceCountListener(this);
   else
     adb_bridge->RemoveDeviceCountListener(this);
 }
 
-void DevToolsUIBindings::SetDevicesUpdatesEnabled(bool enabled) {
+void DevToolsUIBindings::SetDevicesUpdatesEnabled(int request_id,
+                                                  bool enabled) {
   if (devices_updates_enabled_ == enabled)
     return;
   devices_updates_enabled_ = enabled;
   if (enabled) {
     remote_targets_handler_ = DevToolsTargetsUIHandler::CreateForAdb(
         base::Bind(&DevToolsUIBindings::DevicesUpdated,
                    base::Unretained(this)),
         profile_);
   } else {
     remote_targets_handler_.reset();
   }
 }
 
-void DevToolsUIBindings::SendMessageToBrowser(const std::string& message) {
+void DevToolsUIBindings::SendMessageToBrowser(int request_id,
+                                              const std::string& message) {
   if (agent_host_.get())
     agent_host_->DispatchProtocolMessage(message);
 }
 
-void DevToolsUIBindings::RecordActionUMA(const std::string& name, int action) {
+void DevToolsUIBindings::RecordActionUMA(int request_id,
+                                         const std::string& name,
+                                         int action) {
   if (name == kDevToolsActionTakenHistogram)
     UMA_HISTOGRAM_ENUMERATION(name, action, kDevToolsActionTakenBoundary);
   else if (name == kDevToolsPanelShownHistogram)
     UMA_HISTOGRAM_ENUMERATION(name, action, kDevToolsPanelShownBoundary);
 }
 
+void DevToolsUIBindings::SendJsonRequest(int request_id,
+                                         const std::string& browser_id,
+                                         const std::string& url) {
+  remote_targets_handler_->SendJsonRequest(browser_id, url,
+      base::Bind(&DevToolsUIBindings::JsonReceived,
+                 weak_factory_.GetWeakPtr(),
+                 request_id));
+}
+
+void DevToolsUIBindings::JsonReceived(int request_id,
+                                      int result,
+                                      const std::string& message) {
+  base::FundamentalValue request_id_value(request_id);
+  if (result != net::OK) {
+    CallClientFunction("DevToolsAPI.embedderMessageAck",
+                       &request_id_value, nullptr, nullptr);
+    return;
+  }
+  base::StringValue message_value(message);
+  CallClientFunction("DevToolsAPI.embedderMessageAck",
+                     &request_id_value, &message_value, nullptr);
+}
+
 void DevToolsUIBindings::DeviceCountChanged(int count) {
   base::FundamentalValue value(count);
-  CallClientFunction("DevToolsAPI.deviceCountUpdated", &value, NULL,
-                     NULL);
+  CallClientFunction("DevToolsAPI.deviceCountUpdated",
+                     &value, nullptr, nullptr);
 }
 
 void DevToolsUIBindings::DevicesUpdated(
     const std::string& source,
     const base::ListValue& targets) {
-  CallClientFunction("DevToolsAPI.devicesUpdated", &targets, NULL,
-                     NULL);
+  CallClientFunction("DevToolsAPI.devicesUpdated", &targets, nullptr, nullptr);
 }
 
 void DevToolsUIBindings::FileSavedAs(const std::string& url) {
   base::StringValue url_value(url);
-  CallClientFunction("DevToolsAPI.savedURL", &url_value, NULL, NULL);
+  CallClientFunction("DevToolsAPI.savedURL", &url_value, nullptr, nullptr);
 }
 
 void DevToolsUIBindings::CanceledFileSaveAs(const std::string& url) {
   base::StringValue url_value(url);
   CallClientFunction("DevToolsAPI.canceledSaveURL",
-                     &url_value, NULL, NULL);
+                     &url_value, nullptr, nullptr);
 }
 
 void DevToolsUIBindings::AppendedTo(const std::string& url) {
   base::StringValue url_value(url);
-  CallClientFunction("DevToolsAPI.appendedToURL", &url_value, NULL,
-                     NULL);
+  CallClientFunction("DevToolsAPI.appendedToURL", &url_value, nullptr, nullptr);
 }
 
 void DevToolsUIBindings::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]));
+  for (const DevToolsFileHelper::FileSystem& file_system : file_systems) {
+    file_systems_value.Append(CreateFileSystemValue(file_system));
+  }
   CallClientFunction("DevToolsAPI.fileSystemsLoaded",
-                     &file_systems_value, NULL, NULL);
+                     &file_systems_value, nullptr, nullptr);
 }
 
 void DevToolsUIBindings::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("DevToolsAPI.fileSystemAdded",
-                     error_string_value.get(), file_system_value.get(), NULL);
+  CallClientFunction("DevToolsAPI.fileSystemAdded", error_string_value.get(),
+                     file_system_value.get(), nullptr);
 }
 
 void DevToolsUIBindings::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);
@@ skipping 13 matching lines @@
                      &file_system_path_value, &worked_value);
 }
 
 void DevToolsUIBindings::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("DevToolsAPI.indexingDone", &request_id_value,
-                     &file_system_path_value, NULL);
+                     &file_system_path_value, nullptr);
 }
 
 void DevToolsUIBindings::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);
+  for (const std::string& file_path : file_paths) {
+    file_paths_value.AppendString(file_path);
   }
   base::FundamentalValue request_id_value(request_id);
   base::StringValue file_system_path_value(file_system_path);
   CallClientFunction("DevToolsAPI.searchCompleted", &request_id_value,
                      &file_system_path_value, &file_paths_value);
 }
 
 void DevToolsUIBindings::ShowDevToolsConfirmInfoBar(
     const base::string16& message,
     const InfoBarCallback& callback) {
@@ skipping 19 matching lines @@
   if (!registry)
     return;
 
   base::ListValue results;
   for (const scoped_refptr<const extensions::Extension>& extension :
        registry->enabled_extensions()) {
     if (extensions::chrome_manifest_urls::GetDevToolsPage(extension.get())
             .is_empty())
       continue;
     base::DictionaryValue* extension_info = new base::DictionaryValue();
-    extension_info->Set(
-        "startPage",
-        new base::StringValue(extensions::chrome_manifest_urls::GetDevToolsPage(
-                                  extension.get()).spec()));
-    extension_info->Set("name", new base::StringValue(extension->name()));
-    extension_info->Set("exposeExperimentalAPIs",
-                        new base::FundamentalValue(
-                            extension->permissions_data()->HasAPIPermission(
-                                extensions::APIPermission::kExperimental)));
+    extension_info->SetString("startPage",
+        extensions::chrome_manifest_urls::GetDevToolsPage(
+             extension.get()).spec());
+    extension_info->SetString("name", extension->name());
+    extension_info->SetBoolean("exposeExperimentalAPIs",
+        extension->permissions_data()->HasAPIPermission(
+            extensions::APIPermission::kExperimental));
     results.Append(extension_info);
   }
-  CallClientFunction("DevToolsAPI.addExtensions",
-                     &results, NULL, NULL);
+  CallClientFunction("DevToolsAPI.addExtensions", &results, nullptr, nullptr);
 }
 
 void DevToolsUIBindings::SetDelegate(Delegate* delegate) {
   delegate_.reset(delegate);
 }
 
 void DevToolsUIBindings::AttachTo(
     const scoped_refptr<content::DevToolsAgentHost>& agent_host) {
   if (agent_host_.get())
     Detach();
   agent_host_ = agent_host;
   agent_host_->AttachClient(this);
 }
 
 void DevToolsUIBindings::Reattach() {
   DCHECK(agent_host_.get());
   agent_host_->DetachClient();
   agent_host_->AttachClient(this);
 }
 
 void DevToolsUIBindings::Detach() {
   if (agent_host_.get())
     agent_host_->DetachClient();
-  agent_host_ = NULL;
+  agent_host_ = nullptr;
 }
 
 bool DevToolsUIBindings::IsAttachedTo(content::DevToolsAgentHost* agent_host) {
   return agent_host_.get() == agent_host;
 }
 
 void DevToolsUIBindings::CallClientFunction(const std::string& function_name,
                                             const base::Value* arg1,
                                             const base::Value* arg2,
                                             const base::Value* arg3) {
@@ skipping 33 matching lines @@
   if (frontend_loaded_)
     return;
   frontend_loaded_ = true;
 
   // Call delegate first - it seeds importants bit of information.
   delegate_->OnLoadCompleted();
 
   UpdateTheme();
   AddDevToolsExtensionsToClient();
 }