BASELINE: Update Chromium to 52.0.2743.76 and Ninja to 1.7.1

Change-Id: I382f51b959689505a60f8b707255ecb344f7d8b4
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

51 files changed, 592 insertions, 509 deletions

diff --git a/chromium/content/browser/devtools/browser_devtools_agent_host.h b/chromium/content/browser/devtools/browser_devtools_agent_host.h
index 908d48afa81..8f9bf63a653 100644
--- a/chromium/content/browser/devtools/browser_devtools_agent_host.h
+++ b/chromium/content/browser/devtools/browser_devtools_agent_host.h
@@ -39,12 +39,13 @@ class BrowserDevToolsAgentHost : public DevToolsAgentHostImpl {
   bool Close() override;
   bool DispatchProtocolMessage(const std::string& message) override;
 
-  scoped_ptr<devtools::io::IOHandler> io_handler_;
-  scoped_ptr<devtools::memory::MemoryHandler> memory_handler_;
-  scoped_ptr<devtools::system_info::SystemInfoHandler> system_info_handler_;
-  scoped_ptr<devtools::tethering::TetheringHandler> tethering_handler_;
-  scoped_ptr<devtools::tracing::TracingHandler> tracing_handler_;
-  scoped_ptr<DevToolsProtocolHandler> protocol_handler_;
+  std::unique_ptr<devtools::io::IOHandler> io_handler_;
+  std::unique_ptr<devtools::memory::MemoryHandler> memory_handler_;
+  std::unique_ptr<devtools::system_info::SystemInfoHandler>
+      system_info_handler_;
+  std::unique_ptr<devtools::tethering::TetheringHandler> tethering_handler_;
+  std::unique_ptr<devtools::tracing::TracingHandler> tracing_handler_;
+  std::unique_ptr<DevToolsProtocolHandler> protocol_handler_;
 };
 
 }  // namespace content
diff --git a/chromium/content/browser/devtools/devtools_frame_trace_recorder.cc b/chromium/content/browser/devtools/devtools_frame_trace_recorder.cc
index d5756385810..8d4696fcc53 100644
--- a/chromium/content/browser/devtools/devtools_frame_trace_recorder.cc
+++ b/chromium/content/browser/devtools/devtools_frame_trace_recorder.cc
@@ -78,7 +78,7 @@ void FrameCaptured(base::TimeTicks timestamp, const SkBitmap& bitmap,
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID_AND_TIMESTAMP(
       TRACE_DISABLED_BY_DEFAULT("devtools.screenshot"), "Screenshot", 1,
       timestamp.ToInternalValue(),
-      scoped_ptr<base::trace_event::ConvertableToTraceFormat>(
+      std::unique_ptr<base::trace_event::ConvertableToTraceFormat>(
           new TraceableDevToolsScreenshot(bitmap)));
 }
 
@@ -91,14 +91,20 @@ void CaptureFrame(RenderFrameHostImpl* host,
   int current_frame_count = base::subtle::NoBarrier_Load(&frame_data_count);
   if (current_frame_count >= kMaximumFrameDataCount)
     return;
-  float scale = metadata.page_scale_factor;
-  float area = metadata.scrollable_viewport_size.GetArea();
-  if (area * scale * scale > kFrameAreaLimit)
-    scale = sqrt(kFrameAreaLimit / area);
-  gfx::Size snapshot_size(gfx::ToRoundedSize(gfx::ScaleSize(
-      metadata.scrollable_viewport_size, scale)));
+
+  gfx::Size src_size = gfx::ToCeiledSize(gfx::ScaleSize(
+      metadata.scrollable_viewport_size, metadata.page_scale_factor));
+  gfx::Size snapshot_size;
+  float area = src_size.GetArea();
+  if (area <= kFrameAreaLimit) {
+    snapshot_size = src_size;
+  } else {
+    double scale = sqrt(kFrameAreaLimit / area);
+    snapshot_size = gfx::ScaleToCeiledSize(src_size, scale);
+  }
+
   view->CopyFromCompositingSurface(
-      gfx::Rect(), snapshot_size,
+      gfx::Rect(gfx::Point(), src_size), snapshot_size,
       base::Bind(FrameCaptured, base::TimeTicks::Now()),
       kN32_SkColorType);
 }
diff --git a/chromium/content/browser/devtools/devtools_frame_trace_recorder.h b/chromium/content/browser/devtools/devtools_frame_trace_recorder.h
index 79c6f16145c..236e14d27b8 100644
--- a/chromium/content/browser/devtools/devtools_frame_trace_recorder.h
+++ b/chromium/content/browser/devtools/devtools_frame_trace_recorder.h
@@ -5,9 +5,10 @@
 #ifndef CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_FRAME_TRACE_RECORDER_H_
 #define CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_FRAME_TRACE_RECORDER_H_
 
+#include <memory>
+
 #include "base/compiler_specific.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 
 namespace cc {
@@ -33,7 +34,7 @@ class DevToolsFrameTraceRecorder {
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DevToolsFrameTraceRecorder);
-  scoped_ptr<cc::CompositorFrameMetadata> last_metadata_;
+  std::unique_ptr<cc::CompositorFrameMetadata> last_metadata_;
 };
 
 }  // namespace content
diff --git a/chromium/content/browser/devtools/devtools_manager.cc b/chromium/content/browser/devtools/devtools_manager.cc
index 8b269b265fd..f3004a3e7e7 100644
--- a/chromium/content/browser/devtools/devtools_manager.cc
+++ b/chromium/content/browser/devtools/devtools_manager.cc
@@ -7,7 +7,7 @@
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "content/browser/devtools/devtools_agent_host_impl.h"
-#include "content/browser/devtools/devtools_netlog_observer.h"
+#include "content/browser/loader/netlog_observer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 
@@ -34,7 +34,7 @@ void DevToolsManager::AgentHostStateChanged(
       BrowserThread::PostTask(
           BrowserThread::IO,
           FROM_HERE,
-          base::Bind(&DevToolsNetLogObserver::Attach));
+          base::Bind(&NetLogObserver::Attach));
     }
     ++attached_hosts_count_;
   } else {
@@ -43,7 +43,7 @@ void DevToolsManager::AgentHostStateChanged(
       BrowserThread::PostTask(
           BrowserThread::IO,
           FROM_HERE,
-          base::Bind(&DevToolsNetLogObserver::Detach));
+          base::Bind(&NetLogObserver::Detach));
     }
   }
 }
diff --git a/chromium/content/browser/devtools/devtools_manager.h b/chromium/content/browser/devtools/devtools_manager.h
index f803c1331d7..54d2f99f746 100644
--- a/chromium/content/browser/devtools/devtools_manager.h
+++ b/chromium/content/browser/devtools/devtools_manager.h
@@ -5,9 +5,10 @@
 #ifndef CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_MANAGER_H_
 #define CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_MANAGER_H_
 
+#include <memory>
+
 #include "base/compiler_specific.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/devtools_manager_delegate.h"
@@ -35,7 +36,7 @@ class CONTENT_EXPORT DevToolsManager {
  private:
   friend struct base::DefaultSingletonTraits<DevToolsManager>;
 
-  scoped_ptr<DevToolsManagerDelegate> delegate_;
+  std::unique_ptr<DevToolsManagerDelegate> delegate_;
   int attached_hosts_count_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsManager);
diff --git a/chromium/content/browser/devtools/devtools_manager_unittest.cc b/chromium/content/browser/devtools/devtools_manager_unittest.cc
index 24d8dc0d5f4..3aee809d927 100644
--- a/chromium/content/browser/devtools/devtools_manager_unittest.cc
+++ b/chromium/content/browser/devtools/devtools_manager_unittest.cc
@@ -2,13 +2,15 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "content/browser/devtools/devtools_manager.h"
+
+#include <memory>
+
 #include "base/location.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
-#include "base/thread_task_runner_handle.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
-#include "content/browser/devtools/devtools_manager.h"
 #include "content/browser/devtools/shared_worker_devtools_manager.h"
 #include "content/browser/shared_worker/shared_worker_instance.h"
 #include "content/browser/shared_worker/worker_storage_partition.h"
diff --git a/chromium/content/browser/devtools/devtools_netlog_observer.cc b/chromium/content/browser/devtools/devtools_netlog_observer.cc
deleted file mode 100644
index 6a2a3c45be0..00000000000
--- a/chromium/content/browser/devtools/devtools_netlog_observer.cc
+++ /dev/null
@@ -1,207 +0,0 @@
-// Copyright (c) 2012 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/devtools_netlog_observer.h"
-
-#include <stddef.h>
-
-#include "base/strings/string_util.h"
-#include "base/values.h"
-#include "content/browser/loader/resource_request_info_impl.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/browser/content_browser_client.h"
-#include "content/public/common/resource_response.h"
-#include "net/base/load_flags.h"
-#include "net/http/http_response_headers.h"
-#include "net/http/http_util.h"
-#include "net/spdy/spdy_header_block.h"
-#include "net/url_request/url_request.h"
-#include "net/url_request/url_request_netlog_params.h"
-
-namespace content {
-const size_t kMaxNumEntries = 1000;
-
-DevToolsNetLogObserver* DevToolsNetLogObserver::instance_ = NULL;
-
-DevToolsNetLogObserver::DevToolsNetLogObserver() {
-}
-
-DevToolsNetLogObserver::~DevToolsNetLogObserver() {
-}
-
-DevToolsNetLogObserver::ResourceInfo* DevToolsNetLogObserver::GetResourceInfo(
-    uint32_t id) {
-  RequestToInfoMap::iterator it = request_to_info_.find(id);
-  if (it != request_to_info_.end())
-    return it->second.get();
-  return NULL;
-}
-
-void DevToolsNetLogObserver::OnAddEntry(const net::NetLog::Entry& entry) {
-  // The events that the Observer is interested in only occur on the IO thread.
-  if (!BrowserThread::CurrentlyOn(BrowserThread::IO))
-    return;
-
-  if (entry.source().type == net::NetLog::SOURCE_URL_REQUEST)
-    OnAddURLRequestEntry(entry);
-}
-
-void DevToolsNetLogObserver::OnAddURLRequestEntry(
-    const net::NetLog::Entry& entry) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  bool is_begin = entry.phase() == net::NetLog::PHASE_BEGIN;
-  bool is_end = entry.phase() == net::NetLog::PHASE_END;
-
-  if (entry.type() == net::NetLog::TYPE_URL_REQUEST_START_JOB) {
-    if (is_begin) {
-      if (request_to_info_.size() > kMaxNumEntries) {
-        LOG(WARNING) << "The raw headers observer url request count has grown "
-                        "larger than expected, resetting";
-        request_to_info_.clear();
-      }
-
-      request_to_info_[entry.source().id] = new ResourceInfo();
-    }
-    return;
-  } else if (entry.type() == net::NetLog::TYPE_REQUEST_ALIVE) {
-    // Cleanup records based on the TYPE_REQUEST_ALIVE entry.
-    if (is_end)
-      request_to_info_.erase(entry.source().id);
-    return;
-  }
-
-  ResourceInfo* info = GetResourceInfo(entry.source().id);
-  if (!info)
-    return;
-
-  switch (entry.type()) {
-    case net::NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_HEADERS: {
-      scoped_ptr<base::Value> event_params(entry.ParametersToValue());
-      std::string request_line;
-      net::HttpRequestHeaders request_headers;
-
-      if (!net::HttpRequestHeaders::FromNetLogParam(event_params.get(),
-                                                    &request_headers,
-                                                    &request_line)) {
-        NOTREACHED();
-      }
-
-      // We need to clear headers in case the same url_request is reused for
-      // several http requests (e.g. see http://crbug.com/80157).
-      info->request_headers.clear();
-
-      for (net::HttpRequestHeaders::Iterator it(request_headers);
-           it.GetNext();) {
-        info->request_headers.push_back(std::make_pair(it.name(), it.value()));
-      }
-      info->request_headers_text = request_line + request_headers.ToString();
-      break;
-    }
-    case net::NetLog::TYPE_HTTP_TRANSACTION_HTTP2_SEND_REQUEST_HEADERS: {
-      scoped_ptr<base::Value> event_params(entry.ParametersToValue());
-      net::SpdyHeaderBlock request_headers;
-
-      if (!net::SpdyHeaderBlockFromNetLogParam(event_params.get(),
-                                               &request_headers)) {
-        NOTREACHED();
-      }
-
-      // We need to clear headers in case the same url_request is reused for
-      // several http requests (e.g. see http://crbug.com/80157).
-      info->request_headers.clear();
-
-      for (net::SpdyHeaderBlock::const_iterator it = request_headers.begin();
-           it != request_headers.end(); ++it) {
-        info->request_headers.push_back(
-            std::make_pair(it->first.as_string(), it->second.as_string()));
-      }
-      info->request_headers_text = "";
-      break;
-    }
-    case net::NetLog::TYPE_HTTP_TRANSACTION_READ_RESPONSE_HEADERS: {
-      scoped_ptr<base::Value> event_params(entry.ParametersToValue());
-
-      scoped_refptr<net::HttpResponseHeaders> response_headers;
-
-      if (!net::HttpResponseHeaders::FromNetLogParam(event_params.get(),
-                                                     &response_headers)) {
-        NOTREACHED();
-      }
-
-      info->http_status_code = response_headers->response_code();
-      info->http_status_text = response_headers->GetStatusText();
-      std::string name, value;
-
-      // We need to clear headers in case the same url_request is reused for
-      // several http requests (e.g. see http://crbug.com/80157).
-      info->response_headers.clear();
-
-      for (size_t it = 0;
-           response_headers->EnumerateHeaderLines(&it, &name, &value);) {
-        info->response_headers.push_back(std::make_pair(name, value));
-      }
-
-      if (!info->request_headers_text.empty()) {
-        info->response_headers_text =
-            net::HttpUtil::ConvertHeadersBackToHTTPResponse(
-                response_headers->raw_headers());
-      } else {
-        // SPDY request.
-        info->response_headers_text = "";
-      }
-      break;
-    }
-    default:
-      break;
-  }
-}
-
-void DevToolsNetLogObserver::Attach() {
-  DCHECK(!instance_);
-  net::NetLog* net_log = GetContentClient()->browser()->GetNetLog();
-  if (net_log) {
-    instance_ = new DevToolsNetLogObserver();
-    net_log->DeprecatedAddObserver(
-        instance_, net::NetLogCaptureMode::IncludeCookiesAndCredentials());
-  }
-}
-
-void DevToolsNetLogObserver::Detach() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  if (instance_) {
-    // Safest not to do this in the destructor to maintain thread safety across
-    // refactorings.
-    instance_->net_log()->DeprecatedRemoveObserver(instance_);
-    delete instance_;
-    instance_ = NULL;
-  }
-}
-
-DevToolsNetLogObserver* DevToolsNetLogObserver::GetInstance() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  return instance_;
-}
-
-// static
-void DevToolsNetLogObserver::PopulateResponseInfo(
-    net::URLRequest* request,
-    ResourceResponse* response) {
-  const ResourceRequestInfoImpl* request_info =
-      ResourceRequestInfoImpl::ForRequest(request);
-  if (!request_info || !request_info->ShouldReportRawHeaders())
-    return;
-
-  uint32_t source_id = request->net_log().source().id;
-  DevToolsNetLogObserver* dev_tools_net_log_observer =
-      DevToolsNetLogObserver::GetInstance();
-  if (dev_tools_net_log_observer == NULL)
-    return;
-  response->head.devtools_info =
-      dev_tools_net_log_observer->GetResourceInfo(source_id);
-}
-
-}  // namespace content
diff --git a/chromium/content/browser/devtools/devtools_netlog_observer.h b/chromium/content/browser/devtools/devtools_netlog_observer.h
deleted file mode 100644
index cde0133bc29..00000000000
--- a/chromium/content/browser/devtools/devtools_netlog_observer.h
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright (c) 2012 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.
-
-#ifndef CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_NETLOG_OBSERVER_H_
-#define CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_NETLOG_OBSERVER_H_
-
-#include <stdint.h>
-
-#include "base/containers/hash_tables.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "content/public/common/resource_devtools_info.h"
-#include "net/log/net_log.h"
-
-namespace net {
-class URLRequest;
-}  // namespace net
-
-namespace content {
-struct ResourceResponse;
-
-// DevToolsNetLogObserver watches the NetLog event stream and collects the
-// stuff that may be of interest to DevTools. Currently, this only includes
-// actual HTTP/SPDY headers sent and received over the network.
-//
-// As DevToolsNetLogObserver shares live data with objects that live on the
-// IO Thread, it must also reside on the IO Thread.  Only OnAddEntry can be
-// called from other threads.
-class DevToolsNetLogObserver : public net::NetLog::ThreadSafeObserver {
-  typedef ResourceDevToolsInfo ResourceInfo;
-
- public:
-  // net::NetLog::ThreadSafeObserver implementation:
-  void OnAddEntry(const net::NetLog::Entry& entry) override;
-
-  void OnAddURLRequestEntry(const net::NetLog::Entry& entry);
-
-  static void Attach();
-  static void Detach();
-
-  // Must be called on the IO thread. May return NULL if no observers
-  // are active.
-  static DevToolsNetLogObserver* GetInstance();
-  static void PopulateResponseInfo(net::URLRequest*,
-                                   ResourceResponse*);
-
- private:
-  static DevToolsNetLogObserver* instance_;
-
-  DevToolsNetLogObserver();
-  ~DevToolsNetLogObserver() override;
-
-  ResourceInfo* GetResourceInfo(uint32_t id);
-
-  typedef base::hash_map<uint32_t, scoped_refptr<ResourceInfo>>
-      RequestToInfoMap;
-  RequestToInfoMap request_to_info_;
-
-  DISALLOW_COPY_AND_ASSIGN(DevToolsNetLogObserver);
-};
-
-}  // namespace content
-
-#endif  // CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_NETLOG_OBSERVER_H_
diff --git a/chromium/content/browser/devtools/devtools_protocol_handler.cc b/chromium/content/browser/devtools/devtools_protocol_handler.cc
index e92ef84f389..be689d43acf 100644
--- a/chromium/content/browser/devtools/devtools_protocol_handler.cc
+++ b/chromium/content/browser/devtools/devtools_protocol_handler.cc
@@ -9,6 +9,7 @@
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
+#include "base/memory/ptr_util.h"
 #include "content/browser/devtools/devtools_agent_host_impl.h"
 #include "content/browser/devtools/devtools_manager.h"
 #include "content/public/browser/devtools_manager_delegate.h"
@@ -26,14 +27,15 @@ const int kStatusParseError = -32700;
 const int kStatusInvalidRequest = -32600;
 const int kStatusNoSuchMethod = -32601;
 
-scoped_ptr<base::DictionaryValue> TakeDictionary(base::DictionaryValue* dict,
-                                                 const std::string& key) {
-  scoped_ptr<base::Value> value;
+std::unique_ptr<base::DictionaryValue> TakeDictionary(
+    base::DictionaryValue* dict,
+    const std::string& key) {
+  std::unique_ptr<base::Value> value;
   dict->Remove(key, &value);
   base::DictionaryValue* result = nullptr;
   if (value)
     value.release()->GetAsDictionary(&result);
-  return make_scoped_ptr(result);
+  return base::WrapUnique(result);
 }
 
 }  // namespace
@@ -47,7 +49,8 @@ DevToolsProtocolHandler::~DevToolsProtocolHandler() {
 
 void DevToolsProtocolHandler::HandleMessage(int session_id,
                                             const std::string& message) {
-  scoped_ptr<base::DictionaryValue> command = ParseCommand(session_id, message);
+  std::unique_ptr<base::DictionaryValue> command =
+      ParseCommand(session_id, message);
   if (!command)
     return;
   if (PassCommandToDelegate(session_id, command.get()))
@@ -57,13 +60,15 @@ void DevToolsProtocolHandler::HandleMessage(int session_id,
 
 bool DevToolsProtocolHandler::HandleOptionalMessage(int session_id,
                                                     const std::string& message,
-                                                    int* call_id) {
-  scoped_ptr<base::DictionaryValue> command = ParseCommand(session_id, message);
+                                                    int* call_id,
+                                                    std::string* method) {
+  std::unique_ptr<base::DictionaryValue> command =
+      ParseCommand(session_id, message);
   if (!command)
     return true;
   if (PassCommandToDelegate(session_id, command.get()))
     return true;
-  return HandleOptionalCommand(session_id, std::move(command), call_id);
+  return HandleOptionalCommand(session_id, std::move(command), call_id, method);
 }
 
 bool DevToolsProtocolHandler::PassCommandToDelegate(
@@ -74,7 +79,7 @@ bool DevToolsProtocolHandler::PassCommandToDelegate(
   if (!delegate)
     return false;
 
-  scoped_ptr<base::DictionaryValue> response(
+  std::unique_ptr<base::DictionaryValue> response(
       delegate->HandleCommand(agent_host_, command));
   if (response) {
     client_.SendMessage(session_id, *response);
@@ -84,10 +89,10 @@ bool DevToolsProtocolHandler::PassCommandToDelegate(
   return false;
 }
 
-scoped_ptr<base::DictionaryValue> DevToolsProtocolHandler::ParseCommand(
+std::unique_ptr<base::DictionaryValue> DevToolsProtocolHandler::ParseCommand(
     int session_id,
     const std::string& message) {
-  scoped_ptr<base::Value> value = base::JSONReader::Read(message);
+  std::unique_ptr<base::Value> value = base::JSONReader::Read(message);
   if (!value || !value->IsType(base::Value::TYPE_DICTIONARY)) {
     client_.SendError(
         DevToolsCommandId(DevToolsCommandId::kNoId, session_id),
@@ -95,8 +100,8 @@ scoped_ptr<base::DictionaryValue> DevToolsProtocolHandler::ParseCommand(
     return nullptr;
   }
 
-  scoped_ptr<base::DictionaryValue> command =
-      make_scoped_ptr(static_cast<base::DictionaryValue*>(value.release()));
+  std::unique_ptr<base::DictionaryValue> command =
+      base::WrapUnique(static_cast<base::DictionaryValue*>(value.release()));
   int call_id = DevToolsCommandId::kNoId;
   bool ok = command->GetInteger(kIdParam, &call_id) && call_id >= 0;
   if (!ok) {
@@ -120,7 +125,7 @@ scoped_ptr<base::DictionaryValue> DevToolsProtocolHandler::ParseCommand(
 
 void DevToolsProtocolHandler::HandleCommand(
     int session_id,
-    scoped_ptr<base::DictionaryValue> command) {
+    std::unique_ptr<base::DictionaryValue> command) {
   int call_id = DevToolsCommandId::kNoId;
   std::string method;
   command->GetInteger(kIdParam, &call_id);
@@ -141,14 +146,14 @@ void DevToolsProtocolHandler::HandleCommand(
 
 bool DevToolsProtocolHandler::HandleOptionalCommand(
     int session_id,
-    scoped_ptr<base::DictionaryValue> command,
-    int* call_id) {
+    std::unique_ptr<base::DictionaryValue> command,
+    int* call_id,
+    std::string* method) {
   *call_id = DevToolsCommandId::kNoId;
-  std::string method;
   command->GetInteger(kIdParam, call_id);
-  command->GetString(kMethodParam, &method);
+  command->GetString(kMethodParam, method);
   DevToolsProtocolDispatcher::CommandHandler command_handler(
-      dispatcher_.FindCommandHandler(method));
+      dispatcher_.FindCommandHandler(*method));
   if (!command_handler.is_null()) {
     return command_handler.Run(DevToolsCommandId(*call_id, session_id),
                                TakeDictionary(command.get(), kParamsParam));
diff --git a/chromium/content/browser/devtools/devtools_protocol_handler.h b/chromium/content/browser/devtools/devtools_protocol_handler.h
index 32f49287d84..b91c2eb8aa1 100644
--- a/chromium/content/browser/devtools/devtools_protocol_handler.h
+++ b/chromium/content/browser/devtools/devtools_protocol_handler.h
@@ -23,18 +23,22 @@ class DevToolsProtocolHandler {
   void HandleMessage(int session_id, const std::string& message);
   bool HandleOptionalMessage(int session_id,
                              const std::string& message,
-                             int* call_id);
+                             int* call_id,
+                             std::string* method);
 
   DevToolsProtocolDispatcher* dispatcher() { return &dispatcher_; }
 
  private:
-  scoped_ptr<base::DictionaryValue> ParseCommand(int session_id,
-                                                 const std::string& message);
+  std::unique_ptr<base::DictionaryValue> ParseCommand(
+      int session_id,
+      const std::string& message);
   bool PassCommandToDelegate(int session_id, base::DictionaryValue* command);
-  void HandleCommand(int session_id, scoped_ptr<base::DictionaryValue> command);
+  void HandleCommand(int session_id,
+                     std::unique_ptr<base::DictionaryValue> command);
   bool HandleOptionalCommand(int session_id,
-                             scoped_ptr<base::DictionaryValue> command,
-                             int* call_id);
+                             std::unique_ptr<base::DictionaryValue> command,
+                             int* call_id,
+                             std::string* method);
 
   DevToolsAgentHost* agent_host_;
   DevToolsProtocolClient client_;
diff --git a/chromium/content/browser/devtools/forwarding_agent_host.h b/chromium/content/browser/devtools/forwarding_agent_host.h
index 2b6ccce3050..dc8c4269035 100644
--- a/chromium/content/browser/devtools/forwarding_agent_host.h
+++ b/chromium/content/browser/devtools/forwarding_agent_host.h
@@ -5,8 +5,9 @@
 #ifndef CONTENT_BROWSER_DEVTOOLS_FORWARDING_AGENT_HOST_H_
 #define CONTENT_BROWSER_DEVTOOLS_FORWARDING_AGENT_HOST_H_
 
+#include <memory>
+
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "content/browser/devtools/devtools_agent_host_impl.h"
 #include "content/public/browser/devtools_external_agent_proxy.h"
 #include "content/public/browser/devtools_external_agent_proxy_delegate.h"
@@ -38,7 +39,7 @@ class ForwardingAgentHost
   bool Activate() override;
   bool Close() override;
 
-  scoped_ptr<DevToolsExternalAgentProxyDelegate> delegate_;
+  std::unique_ptr<DevToolsExternalAgentProxyDelegate> delegate_;
 };
 
 }  // namespace content
diff --git a/chromium/content/browser/devtools/protocol/color_picker.cc b/chromium/content/browser/devtools/protocol/color_picker.cc
index b87c303edc5..3016caf9b34 100644
--- a/chromium/content/browser/devtools/protocol/color_picker.cc
+++ b/chromium/content/browser/devtools/protocol/color_picker.cc
@@ -181,7 +181,7 @@ void ColorPicker::UpdateCursor() {
   SkPaint paint;
 
   // Paint original spot with cross.
-  if (kHotspotRadius) {
+  if (kHotspotRadius > 0) {
     paint.setStrokeWidth(1);
     paint.setAntiAlias(false);
     paint.setColor(SK_ColorDKGRAY);
@@ -253,9 +253,6 @@ void ColorPicker::UpdateCursor() {
   cursor_info.hotspot =
       gfx::Point(kHotspotOffset * device_scale_factor,
                  kHotspotOffset * device_scale_factor);
-#if defined(OS_WIN)
-  cursor_info.external_handle = 0;
-#endif
 
   cursor.InitFromCursorInfo(cursor_info);
   DCHECK(host_);
diff --git a/chromium/content/browser/devtools/protocol/devtools_protocol_browsertest.cc b/chromium/content/browser/devtools/protocol/devtools_protocol_browsertest.cc
index 3f471114c64..0a243395c5f 100644
--- a/chromium/content/browser/devtools/protocol/devtools_protocol_browsertest.cc
+++ b/chromium/content/browser/devtools/protocol/devtools_protocol_browsertest.cc
@@ -12,6 +12,7 @@
 #include "base/values.h"
 #include "build/build_config.h"
 #include "content/public/browser/devtools_agent_host.h"
+#include "content/public/browser/javascript_dialog_manager.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
@@ -34,6 +35,64 @@ const char kIdParam[] = "id";
 const char kMethodParam[] = "method";
 const char kParamsParam[] = "params";
 
+class TestJavaScriptDialogManager : public JavaScriptDialogManager,
+                                    public WebContentsDelegate {
+ public:
+  TestJavaScriptDialogManager() : handle_(false) {}
+  ~TestJavaScriptDialogManager() override {}
+
+  void Handle()
+  {
+    if (!callback_.is_null()) {
+      callback_.Run(true, base::string16());
+      callback_.Reset();
+    } else {
+      handle_ = true;
+    }
+  }
+
+  // WebContentsDelegate
+  JavaScriptDialogManager* GetJavaScriptDialogManager(
+      WebContents* source) override {
+    return this;
+  }
+
+  // JavaScriptDialogManager
+  void RunJavaScriptDialog(WebContents* web_contents,
+                           const GURL& origin_url,
+                           JavaScriptMessageType javascript_message_type,
+                           const base::string16& message_text,
+                           const base::string16& default_prompt_text,
+                           const DialogClosedCallback& callback,
+                           bool* did_suppress_message) override {
+    if (handle_) {
+      handle_ = false;
+      callback.Run(true, base::string16());
+    } else {
+      callback_ = callback;
+    }
+  };
+
+  void RunBeforeUnloadDialog(WebContents* web_contents,
+                             bool is_reload,
+                             const DialogClosedCallback& callback) override {}
+
+  bool HandleJavaScriptDialog(WebContents* web_contents,
+                              bool accept,
+                              const base::string16* prompt_override) override {
+    return true;
+  }
+
+  void CancelActiveAndPendingDialogs(WebContents* web_contents) override {}
+
+  void ResetDialogState(WebContents* web_contents) override {}
+
+ private:
+  DialogClosedCallback callback_;
+  bool handle_;
+  DISALLOW_COPY_AND_ASSIGN(TestJavaScriptDialogManager);
+};
+
 }
 
 class DevToolsProtocolTest : public ContentBrowserTest,
@@ -47,12 +106,12 @@ class DevToolsProtocolTest : public ContentBrowserTest,
 
  protected:
   void SendCommand(const std::string& method,
-                   scoped_ptr<base::DictionaryValue> params) {
+                   std::unique_ptr<base::DictionaryValue> params) {
     SendCommand(method, std::move(params), true);
   }
 
   void SendCommand(const std::string& method,
-                   scoped_ptr<base::DictionaryValue> params,
+                   std::unique_ptr<base::DictionaryValue> params,
                    bool wait) {
     in_dispatch_ = true;
     base::DictionaryValue command;
@@ -115,7 +174,7 @@ class DevToolsProtocolTest : public ContentBrowserTest,
     RunMessageLoop();
   }
 
-  scoped_ptr<base::DictionaryValue> result_;
+  std::unique_ptr<base::DictionaryValue> result_;
   scoped_refptr<DevToolsAgentHost> agent_host_;
   int last_sent_id_;
   std::vector<int> result_ids_;
@@ -124,8 +183,9 @@ class DevToolsProtocolTest : public ContentBrowserTest,
  private:
   void DispatchProtocolMessage(DevToolsAgentHost* agent_host,
                                const std::string& message) override {
-    scoped_ptr<base::DictionaryValue> root(static_cast<base::DictionaryValue*>(
-        base::JSONReader::Read(message).release()));
+    std::unique_ptr<base::DictionaryValue> root(
+        static_cast<base::DictionaryValue*>(
+            base::JSONReader::Read(message).release()));
     int id;
     if (root->GetInteger("id", &id)) {
       result_ids_.push_back(id);
@@ -163,7 +223,7 @@ class SyntheticKeyEventTest : public DevToolsProtocolTest {
                     int modifier,
                     int windowsKeyCode,
                     int nativeKeyCode) {
-    scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
     params->SetString("type", type);
     params->SetInteger("modifiers", modifier);
     params->SetInteger("windowsVirtualKeyCode", windowsKeyCode);
@@ -263,7 +323,7 @@ IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, DISABLED_SynthesizePinchGesture) {
       shell()->web_contents(),
       "domAutomationController.send(window.innerHeight)", &old_height));
 
-  scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
   params->SetInteger("x", old_width / 2);
   params->SetInteger("y", old_height / 2);
   params->SetDouble("scaleFactor", 2.0);
@@ -293,7 +353,7 @@ IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, DISABLED_SynthesizeScrollGesture) {
       "domAutomationController.send(document.body.scrollTop)", &scroll_top));
   ASSERT_EQ(0, scroll_top);
 
-  scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
   params->SetInteger("x", 0);
   params->SetInteger("y", 0);
   params->SetInteger("xDistance", 0);
@@ -317,7 +377,7 @@ IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, DISABLED_SynthesizeTapGesture) {
       "domAutomationController.send(document.body.scrollTop)", &scroll_top));
   ASSERT_EQ(0, scroll_top);
 
-  scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
   params->SetInteger("x", 16);
   params->SetInteger("y", 16);
   params->SetString("gestureSourceType", "touch");
@@ -341,7 +401,7 @@ IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, NavigationPreservesMessages) {
   Attach();
   SendCommand("Page.enable", nullptr, false);
 
-  scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
   test_url = GetTestUrl("devtools", "navigation.html");
   params->SetString("url", test_url.spec());
   TestNavigationObserver navigation_observer(shell()->web_contents());
@@ -491,7 +551,7 @@ IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, ReloadBlankPage) {
 IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, EvaluateInBlankPage) {
   NavigateToURLBlockUntilNavigationsComplete(shell(), GURL("about:blank"), 1);
   Attach();
-  scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
   params->SetString("expression", "window");
   SendCommand("Runtime.evaluate", std::move(params), true);
   bool wasThrown = true;
@@ -506,7 +566,7 @@ IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest,
   NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 1);
   Attach();
   NavigateToURLBlockUntilNavigationsComplete(shell(), GURL("about:blank"), 1);
-  scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
   params->SetString("expression", "window");
   SendCommand("Runtime.evaluate", std::move(params), true);
   bool wasThrown = true;
@@ -514,4 +574,17 @@ IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest,
   EXPECT_FALSE(wasThrown);
 }
 
+IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, JavaScriptDialogNotifications) {
+  NavigateToURLBlockUntilNavigationsComplete(shell(), GURL("about:blank"), 1);
+  Attach();
+  TestJavaScriptDialogManager dialog_manager;
+  shell()->web_contents()->SetDelegate(&dialog_manager);
+  SendCommand("Page.enable", nullptr, true);
+  std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+  params->SetString("expression", "alert('alert')");
+  SendCommand("Runtime.evaluate", std::move(params), false);
+  WaitForNotification("Page.javascriptDialogOpening");
+  dialog_manager.Handle();
+}
+
 }  // namespace content
diff --git a/chromium/content/browser/devtools/protocol/devtools_protocol_client.cc b/chromium/content/browser/devtools/protocol/devtools_protocol_client.cc
index 9ca03f9d1ab..5f132d92cb7 100644
--- a/chromium/content/browser/devtools/protocol/devtools_protocol_client.cc
+++ b/chromium/content/browser/devtools/protocol/devtools_protocol_client.cc
@@ -53,7 +53,7 @@ void DevToolsProtocolClient::SendMessage(int session_id,
 
 void DevToolsProtocolClient::SendNotification(
     const std::string& method,
-    scoped_ptr<base::DictionaryValue> params) {
+    std::unique_ptr<base::DictionaryValue> params) {
   base::DictionaryValue notification;
   notification.SetString(kMethodParam, method);
   if (params)
@@ -66,7 +66,7 @@ void DevToolsProtocolClient::SendNotification(
 
 void DevToolsProtocolClient::SendSuccess(
     DevToolsCommandId command_id,
-    scoped_ptr<base::DictionaryValue> params) {
+    std::unique_ptr<base::DictionaryValue> params) {
   base::DictionaryValue response;
   response.SetInteger(kIdParam, command_id.call_id);
 
diff --git a/chromium/content/browser/devtools/protocol/devtools_protocol_client.h b/chromium/content/browser/devtools/protocol/devtools_protocol_client.h
index ba1a0d79c53..87003f499e9 100644
--- a/chromium/content/browser/devtools/protocol/devtools_protocol_client.h
+++ b/chromium/content/browser/devtools/protocol/devtools_protocol_client.h
@@ -5,9 +5,10 @@
 #ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_CLIENT_H_
 #define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_CLIENT_H_
 
+#include <memory>
+
 #include "base/callback.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 
 namespace content {
@@ -65,9 +66,9 @@ class DevToolsProtocolClient {
 
  protected:
   void SendSuccess(DevToolsCommandId command_id,
-                   scoped_ptr<base::DictionaryValue> params);
+                   std::unique_ptr<base::DictionaryValue> params);
   void SendNotification(const std::string& method,
-                        scoped_ptr<base::DictionaryValue> params);
+                        std::unique_ptr<base::DictionaryValue> params);
 
  private:
   friend class DevToolsProtocolDispatcher;
diff --git a/chromium/content/browser/devtools/protocol/devtools_protocol_handler_generator.py b/chromium/content/browser/devtools/protocol/devtools_protocol_handler_generator.py
index 2f244625c3a..fc1893ec6a0 100755
--- a/chromium/content/browser/devtools/protocol/devtools_protocol_handler_generator.py
+++ b/chromium/content/browser/devtools/protocol/devtools_protocol_handler_generator.py
@@ -31,6 +31,7 @@ template_h = string.Template(header + """\
 
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "content/browser/devtools/protocol/devtools_protocol_client.h"
 
 namespace content {
@@ -49,7 +50,7 @@ base::Value* CreateValue(const T& param) {
 }
 
 template<class T>
-base::Value* CreateValue(scoped_ptr<T>& param) {
+base::Value* CreateValue(std::unique_ptr<T>& param) {
   return param.release();
 }
 
@@ -78,7 +79,7 @@ class DevToolsProtocolDispatcher {
  public:
   using CommandHandler =
       base::Callback<bool(DevToolsCommandId,
-                          scoped_ptr<base::DictionaryValue>)>;
+                          std::unique_ptr<base::DictionaryValue>)>;
 
   explicit DevToolsProtocolDispatcher(DevToolsProtocolDelegate* notifier);
   ~DevToolsProtocolDispatcher();
@@ -127,9 +128,9 @@ ${methods}\
     return new ${declared_name}Builder<kNoneSet>();
   }
 
-  scoped_ptr<base::DictionaryValue> ToValue() {
+  std::unique_ptr<base::DictionaryValue> ToValue() {
     static_assert(MASK == kAllSet, "required properties missing");
-    return make_scoped_ptr(dict_->DeepCopy());
+    return base::WrapUnique(dict_->DeepCopy());
   }
 
  private:
@@ -145,7 +146,7 @@ ${methods}\
     return reinterpret_cast<T*>(this);
   }
 
-  scoped_ptr<base::DictionaryValue> dict_;
+  std::unique_ptr<base::DictionaryValue> dict_;
 };
 
 typedef ${declared_name}Builder<0> ${declared_name};
@@ -237,7 +238,7 @@ tmpl_setter = string.Template("""\
 tmpl_callback = string.Template("""\
   bool On${Domain}${Command}(
       DevToolsCommandId command_id,
-      scoped_ptr<base::DictionaryValue> params);
+      std::unique_ptr<base::DictionaryValue> params);
 """)
 
 tmpl_field = string.Template("""\
@@ -319,22 +320,22 @@ tmpl_register = string.Template("""\
 """)
 
 tmpl_init_client = string.Template("""\
-  ${domain}_handler_->SetClient(make_scoped_ptr(
+  ${domain}_handler_->SetClient(base::WrapUnique(
       new devtools::${domain}::Client(notifier_)));
 """)
 
 tmpl_callback_impl = string.Template("""\
 bool DevToolsProtocolDispatcher::On${Domain}${Command}(
     DevToolsCommandId command_id,
-    scoped_ptr<base::DictionaryValue> params) {
+    std::unique_ptr<base::DictionaryValue> params) {
 ${prep}\
   Response response = ${domain}_handler_->${Command}(${args});
-  scoped_ptr<base::DictionaryValue> protocol_response;
+  std::unique_ptr<base::DictionaryValue> protocol_response;
   if (client_.SendError(command_id, response))
     return true;
   if (response.IsFallThrough())
     return false;
-  scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
 ${wrap}\
   client_.SendSuccess(command_id, std::move(result));
   return true;
@@ -348,7 +349,7 @@ tmpl_wrap = string.Template("""\
 tmpl_callback_async_impl = string.Template("""\
 bool DevToolsProtocolDispatcher::On${Domain}${Command}(
     DevToolsCommandId command_id,
-    scoped_ptr<base::DictionaryValue> params) {
+    std::unique_ptr<base::DictionaryValue> params) {
 ${prep}\
   Response response = ${domain}_handler_->${Command}(${args});
   if (client_.SendError(command_id, response))
@@ -402,7 +403,7 @@ tmpl_arg_opt = string.Template(
     "${param}_found ? ${param_pass} : nullptr")
 
 tmpl_object_pass = string.Template(
-    "make_scoped_ptr<base::DictionaryValue>(${name}->DeepCopy())")
+    "base::WrapUnique<base::DictionaryValue>(${name}->DeepCopy())")
 
 tmpl_client_impl = string.Template("""\
 namespace ${domain} {
@@ -565,7 +566,7 @@ def ResolveArray(json, mapping):
 
 def ResolveObject(json, mapping):
   mapping["Type"] = "Dictionary"
-  mapping["storage_type"] = "scoped_ptr<base::DictionaryValue>"
+  mapping["storage_type"] = "std::unique_ptr<base::DictionaryValue>"
   mapping["raw_type"] = "base::DictionaryValue*"
   mapping["pass_template"] = tmpl_object_pass
   mapping["init"] = " = nullptr"
@@ -583,7 +584,7 @@ def ResolveObject(json, mapping):
     mapping["arg_out"] = "&out_%s" % mapping["param"]
   else:
     mapping["param_type"] = "base::DictionaryValue"
-    mapping["pass_type"] = "scoped_ptr<base::DictionaryValue>"
+    mapping["pass_type"] = "std::unique_ptr<base::DictionaryValue>"
     mapping["arg_out"] = "out_%s.get()" % mapping["param"]
   mapping["prep_req"] = tmpl_prep_req.substitute(mapping)
 
diff --git a/chromium/content/browser/devtools/protocol/emulation_handler.cc b/chromium/content/browser/devtools/protocol/emulation_handler.cc
index 6b124e37131..12c377a4fc8 100644
--- a/chromium/content/browser/devtools/protocol/emulation_handler.cc
+++ b/chromium/content/browser/devtools/protocol/emulation_handler.cc
@@ -85,7 +85,7 @@ Response EmulationHandler::SetGeolocationOverride(
 
   GeolocationServiceContext* geolocation_context =
       GetWebContents()->GetGeolocationServiceContext();
-  scoped_ptr<Geoposition> geoposition(new Geoposition());
+  std::unique_ptr<Geoposition> geoposition(new Geoposition());
   if (latitude && longitude && accuracy) {
     geoposition->latitude = *latitude;
     geoposition->longitude = *longitude;
@@ -146,7 +146,7 @@ Response EmulationHandler::SetDeviceMetricsOverride(
     const int* screen_height,
     const int* position_x,
     const int* position_y,
-    const scoped_ptr<base::DictionaryValue>& screen_orientation) {
+    const std::unique_ptr<base::DictionaryValue>& screen_orientation) {
   const static int max_size = 10000000;
   const static double max_scale = 10;
   const static int max_orientation_angle = 360;
diff --git a/chromium/content/browser/devtools/protocol/emulation_handler.h b/chromium/content/browser/devtools/protocol/emulation_handler.h
index a5aec635500..e61862e66a7 100644
--- a/chromium/content/browser/devtools/protocol/emulation_handler.h
+++ b/chromium/content/browser/devtools/protocol/emulation_handler.h
@@ -52,7 +52,7 @@ class EmulationHandler {
       const int* screen_height,
       const int* position_x,
       const int* position_y,
-      const scoped_ptr<base::DictionaryValue>& screen_orientation);
+      const std::unique_ptr<base::DictionaryValue>& screen_orientation);
   Response ClearDeviceMetricsOverride();
 
  private:
diff --git a/chromium/content/browser/devtools/protocol/input_handler.cc b/chromium/content/browser/devtools/protocol/input_handler.cc
index 08c3cf2cd36..48e901af732 100644
--- a/chromium/content/browser/devtools/protocol/input_handler.cc
+++ b/chromium/content/browser/devtools/protocol/input_handler.cc
@@ -141,7 +141,7 @@ void InputHandler::SetRenderWidgetHost(RenderWidgetHostImpl* host) {
   host_ = host;
 }
 
-void InputHandler::SetClient(scoped_ptr<Client> client) {
+void InputHandler::SetClient(std::unique_ptr<Client> client) {
   client_.swap(client);
 }
 
diff --git a/chromium/content/browser/devtools/protocol/input_handler.h b/chromium/content/browser/devtools/protocol/input_handler.h
index 1bb7be96c74..6e548a5cbcb 100644
--- a/chromium/content/browser/devtools/protocol/input_handler.h
+++ b/chromium/content/browser/devtools/protocol/input_handler.h
@@ -35,7 +35,7 @@ class InputHandler {
   virtual ~InputHandler();
 
   void SetRenderWidgetHost(RenderWidgetHostImpl* host);
-  void SetClient(scoped_ptr<Client> client);
+  void SetClient(std::unique_ptr<Client> client);
   void OnSwapCompositorFrame(const cc::CompositorFrameMetadata& frame_metadata);
 
   Response DispatchKeyEvent(const std::string& type,
@@ -124,7 +124,7 @@ class InputHandler {
                         SyntheticGesture::Result result);
 
   RenderWidgetHostImpl* host_;
-  scoped_ptr<Client> client_;
+  std::unique_ptr<Client> client_;
   float page_scale_factor_;
   gfx::SizeF scrollable_viewport_size_;
   base::WeakPtrFactory<InputHandler> weak_factory_;
diff --git a/chromium/content/browser/devtools/protocol/inspector_handler.cc b/chromium/content/browser/devtools/protocol/inspector_handler.cc
index 8e018a8477e..8777c6a8f47 100644
--- a/chromium/content/browser/devtools/protocol/inspector_handler.cc
+++ b/chromium/content/browser/devtools/protocol/inspector_handler.cc
@@ -19,7 +19,7 @@ InspectorHandler::InspectorHandler()
 InspectorHandler::~InspectorHandler() {
 }
 
-void InspectorHandler::SetClient(scoped_ptr<Client> client) {
+void InspectorHandler::SetClient(std::unique_ptr<Client> client) {
   client_.swap(client);
 }
 
diff --git a/chromium/content/browser/devtools/protocol/inspector_handler.h b/chromium/content/browser/devtools/protocol/inspector_handler.h
index 52325c48a69..cee8949b425 100644
--- a/chromium/content/browser/devtools/protocol/inspector_handler.h
+++ b/chromium/content/browser/devtools/protocol/inspector_handler.h
@@ -22,7 +22,7 @@ class InspectorHandler {
   InspectorHandler();
   virtual ~InspectorHandler();
 
-  void SetClient(scoped_ptr<Client> client);
+  void SetClient(std::unique_ptr<Client> client);
   void SetRenderFrameHost(RenderFrameHostImpl* host);
 
   void TargetCrashed();
@@ -32,7 +32,7 @@ class InspectorHandler {
   Response Disable();
 
  private:
-  scoped_ptr<Client> client_;
+  std::unique_ptr<Client> client_;
   RenderFrameHostImpl* host_;
 
   DISALLOW_COPY_AND_ASSIGN(InspectorHandler);
diff --git a/chromium/content/browser/devtools/protocol/io_handler.cc b/chromium/content/browser/devtools/protocol/io_handler.cc
index 59bef41456f..64dfd954029 100644
--- a/chromium/content/browser/devtools/protocol/io_handler.cc
+++ b/chromium/content/browser/devtools/protocol/io_handler.cc
@@ -28,7 +28,7 @@ IOHandler::IOHandler(DevToolsIOContext* io_context)
 
 IOHandler::~IOHandler() {}
 
-void IOHandler::SetClient(scoped_ptr<Client> client) {
+void IOHandler::SetClient(std::unique_ptr<Client> client) {
   client_.swap(client);
 }
 
diff --git a/chromium/content/browser/devtools/protocol/io_handler.h b/chromium/content/browser/devtools/protocol/io_handler.h
index 951df505dfa..e952bd06372 100644
--- a/chromium/content/browser/devtools/protocol/io_handler.h
+++ b/chromium/content/browser/devtools/protocol/io_handler.h
@@ -26,7 +26,7 @@ class IOHandler {
   explicit IOHandler(DevToolsIOContext* io_context);
   ~IOHandler();
 
-  void SetClient(scoped_ptr<Client> client);
+  void SetClient(std::unique_ptr<Client> client);
 
   // Protocol methods.
   Response Read(DevToolsCommandId command_id, const std::string& handle,
@@ -37,7 +37,7 @@ class IOHandler {
   void ReadComplete(DevToolsCommandId command_id,
       const scoped_refptr<base::RefCountedString>& data, int status);
 
-  scoped_ptr<Client> client_;
+  std::unique_ptr<Client> client_;
   DevToolsIOContext* io_context_;
   base::WeakPtrFactory<IOHandler> weak_factory_;
 
diff --git a/chromium/content/browser/devtools/protocol/network_handler.cc b/chromium/content/browser/devtools/protocol/network_handler.cc
index 5163f19b853..46e07045336 100644
--- a/chromium/content/browser/devtools/protocol/network_handler.cc
+++ b/chromium/content/browser/devtools/protocol/network_handler.cc
@@ -201,7 +201,7 @@ void NetworkHandler::SetRenderFrameHost(RenderFrameHostImpl* host) {
   host_ = host;
 }
 
-void NetworkHandler::SetClient(scoped_ptr<Client> client) {
+void NetworkHandler::SetClient(std::unique_ptr<Client> client) {
   client_.swap(client);
 }
 
diff --git a/chromium/content/browser/devtools/protocol/network_handler.h b/chromium/content/browser/devtools/protocol/network_handler.h
index 3b1456bcacf..9e1c1fc6703 100644
--- a/chromium/content/browser/devtools/protocol/network_handler.h
+++ b/chromium/content/browser/devtools/protocol/network_handler.h
@@ -25,7 +25,7 @@ class NetworkHandler {
   virtual ~NetworkHandler();
 
   void SetRenderFrameHost(RenderFrameHostImpl* host);
-  void SetClient(scoped_ptr<Client> client);
+  void SetClient(std::unique_ptr<Client> client);
 
   Response ClearBrowserCache();
   Response ClearBrowserCookies();
@@ -50,7 +50,7 @@ class NetworkHandler {
   void SendDeleteCookieResponse(DevToolsCommandId command_id);
 
   RenderFrameHostImpl* host_;
-  scoped_ptr<Client> client_;
+  std::unique_ptr<Client> client_;
   base::WeakPtrFactory<NetworkHandler> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkHandler);
diff --git a/chromium/content/browser/devtools/protocol/page_handler.cc b/chromium/content/browser/devtools/protocol/page_handler.cc
index d4f6c3976f4..d472554b9e3 100644
--- a/chromium/content/browser/devtools/protocol/page_handler.cc
+++ b/chromium/content/browser/devtools/protocol/page_handler.cc
@@ -12,7 +12,7 @@
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/thread_task_runner_handle.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "content/browser/devtools/protocol/color_picker.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
@@ -136,7 +136,7 @@ void PageHandler::SetRenderFrameHost(RenderFrameHostImpl* host) {
   }
 }
 
-void PageHandler::SetClient(scoped_ptr<Client> client) {
+void PageHandler::SetClient(std::unique_ptr<Client> client) {
   client_.swap(client);
 }
 
diff --git a/chromium/content/browser/devtools/protocol/page_handler.h b/chromium/content/browser/devtools/protocol/page_handler.h
index 067d9587b32..6dbca0a58b4 100644
--- a/chromium/content/browser/devtools/protocol/page_handler.h
+++ b/chromium/content/browser/devtools/protocol/page_handler.h
@@ -37,7 +37,7 @@ class PageHandler : public NotificationObserver {
   ~PageHandler() override;
 
   void SetRenderFrameHost(RenderFrameHostImpl* host);
-  void SetClient(scoped_ptr<Client> client);
+  void SetClient(std::unique_ptr<Client> client);
   void Detached();
   void OnSwapCompositorFrame(const cc::CompositorFrameMetadata& frame_metadata);
   void OnSynchronousSwapCompositorFrame(const cc::CompositorFrameMetadata&
@@ -118,10 +118,10 @@ class PageHandler : public NotificationObserver {
   int frame_counter_;
   int frames_in_flight_;
 
-  scoped_ptr<ColorPicker> color_picker_;
+  std::unique_ptr<ColorPicker> color_picker_;
 
   RenderFrameHostImpl* host_;
-  scoped_ptr<Client> client_;
+  std::unique_ptr<Client> client_;
   NotificationRegistrar registrar_;
   base::WeakPtrFactory<PageHandler> weak_factory_;
 
diff --git a/chromium/content/browser/devtools/protocol/security_handler.cc b/chromium/content/browser/devtools/protocol/security_handler.cc
index 7784651f7b2..913602ee8ad 100644
--- a/chromium/content/browser/devtools/protocol/security_handler.cc
+++ b/chromium/content/browser/devtools/protocol/security_handler.cc
@@ -63,7 +63,7 @@ SecurityHandler::SecurityHandler()
 SecurityHandler::~SecurityHandler() {
 }
 
-void SecurityHandler::SetClient(scoped_ptr<Client> client) {
+void SecurityHandler::SetClient(std::unique_ptr<Client> client) {
   client_.swap(client);
 }
 
diff --git a/chromium/content/browser/devtools/protocol/security_handler.h b/chromium/content/browser/devtools/protocol/security_handler.h
index 3f9ce2b139d..5f5fe68f5aa 100644
--- a/chromium/content/browser/devtools/protocol/security_handler.h
+++ b/chromium/content/browser/devtools/protocol/security_handler.h
@@ -22,7 +22,7 @@ class SecurityHandler : public WebContentsObserver {
   SecurityHandler();
   ~SecurityHandler() override;
 
-  void SetClient(scoped_ptr<Client> client);
+  void SetClient(std::unique_ptr<Client> client);
   void SetRenderFrameHost(RenderFrameHost* host);
 
   Response Enable();
@@ -36,7 +36,7 @@ class SecurityHandler : public WebContentsObserver {
       SecurityStyle security_style,
       const SecurityStyleExplanations& security_style_explanations) override;
 
-  scoped_ptr<Client> client_;
+  std::unique_ptr<Client> client_;
   bool enabled_;
   RenderFrameHost* host_;
 
diff --git a/chromium/content/browser/devtools/protocol/service_worker_handler.cc b/chromium/content/browser/devtools/protocol/service_worker_handler.cc
index b2f5c2572b7..a3034a2a88a 100644
--- a/chromium/content/browser/devtools/protocol/service_worker_handler.cc
+++ b/chromium/content/browser/devtools/protocol/service_worker_handler.cc
@@ -41,6 +41,9 @@ using Response = DevToolsProtocolClient::Response;
 
 namespace {
 
+using ScopeAgentsMap =
+    std::map<GURL, std::unique_ptr<ServiceWorkerDevToolsAgentHost::List>>;
+
 void ResultNoOp(bool success) {
 }
 void StatusNoOp(ServiceWorkerStatusCode status) {
@@ -137,34 +140,47 @@ scoped_refptr<ServiceWorkerRegistration> CreateRegistrationDictionaryValue(
   return registration;
 }
 
-scoped_refptr<ServiceWorkerDevToolsAgentHost> GetMatchingServiceWorker(
+void GetMatchingHostsByScopeMap(
     const ServiceWorkerDevToolsAgentHost::List& agent_hosts,
-    const GURL& url) {
-  scoped_refptr<ServiceWorkerDevToolsAgentHost> best_host;
-  bool best_host_scope_matched = false;
-  int best_host_scope_length = 0;
-
-  for (auto host : agent_hosts) {
-    if (host->GetURL().host_piece() != url.host_piece())
+    const std::set<GURL>& urls,
+    ScopeAgentsMap* scope_agents_map) {
+  std::set<base::StringPiece> host_name_set;
+  for (const GURL& url : urls)
+    host_name_set.insert(url.host_piece());
+  for (const auto& host : agent_hosts) {
+    if (host_name_set.find(host->scope().host_piece()) == host_name_set.end())
       continue;
-    const bool scope_matched =
-        ServiceWorkerUtils::ScopeMatches(host->scope(), url);
-    const int scope_length = host->scope().spec().length();
-    bool replace = false;
-    if (!best_host)
-      replace = true;
-    else if (best_host_scope_matched)
-      replace = scope_matched && scope_length >= best_host_scope_length;
-    else
-      replace = scope_matched || scope_length >= best_host_scope_length;
-
-    if (replace) {
-      best_host = host;
-      best_host_scope_matched = scope_matched;
-      best_host_scope_length = scope_length;
+    const auto& it = scope_agents_map->find(host->scope());
+    if (it == scope_agents_map->end()) {
+      std::unique_ptr<ServiceWorkerDevToolsAgentHost::List> new_list(
+          new ServiceWorkerDevToolsAgentHost::List());
+      new_list->push_back(host);
+      (*scope_agents_map)[host->scope()] = std::move(new_list);
+    } else {
+      it->second->push_back(host);
+    }
+  }
+}
+
+void AddEligibleHosts(const ServiceWorkerDevToolsAgentHost::List& list,
+                      ServiceWorkerDevToolsAgentHost::Map* result) {
+  base::Time last_installed_time;
+  base::Time last_doomed_time;
+  for (const auto& host : list) {
+    if (host->version_installed_time() > last_installed_time)
+      last_installed_time = host->version_installed_time();
+    if (host->version_doomed_time() > last_doomed_time)
+      last_doomed_time = host->version_doomed_time();
+  }
+  for (const auto& host : list) {
+    // We don't attech old redundant Service Workers when there is newer
+    // installed Service Worker.
+    if (host->version_doomed_time().is_null() ||
+        (last_installed_time < last_doomed_time &&
+         last_doomed_time == host->version_doomed_time())) {
+      (*result)[host->GetId()] = host;
     }
   }
-  return best_host;
 }
 
 ServiceWorkerDevToolsAgentHost::Map GetMatchingServiceWorkers(
@@ -173,15 +189,17 @@ ServiceWorkerDevToolsAgentHost::Map GetMatchingServiceWorkers(
   ServiceWorkerDevToolsAgentHost::Map result;
   if (!browser_context)
     return result;
+
   ServiceWorkerDevToolsAgentHost::List agent_hosts;
   ServiceWorkerDevToolsManager::GetInstance()
       ->AddAllAgentHostsForBrowserContext(browser_context, &agent_hosts);
-  for (const GURL& url : urls) {
-    scoped_refptr<ServiceWorkerDevToolsAgentHost> host =
-        GetMatchingServiceWorker(agent_hosts, url);
-    if (host)
-      result[host->GetId()] = host;
-  }
+
+  ScopeAgentsMap scope_agents_map;
+  GetMatchingHostsByScopeMap(agent_hosts, urls, &scope_agents_map);
+
+  for (const auto& it : scope_agents_map)
+    AddEligibleHosts(*it.second.get(), &result);
+
   return result;
 }
 
@@ -262,7 +280,7 @@ void ServiceWorkerHandler::SetRenderFrameHost(
       partition->GetServiceWorkerContext());
 }
 
-void ServiceWorkerHandler::SetClient(scoped_ptr<Client> client) {
+void ServiceWorkerHandler::SetClient(std::unique_ptr<Client> client) {
   client_.swap(client);
 }
 
@@ -374,6 +392,15 @@ Response ServiceWorkerHandler::StartWorker(const std::string& scope_url) {
   return Response::OK();
 }
 
+Response ServiceWorkerHandler::SkipWaiting(const std::string& scope_url) {
+  if (!enabled_)
+    return Response::OK();
+  if (!context_)
+    return CreateContextErrorResponse();
+  context_->SkipWaitingWorker(GURL(scope_url));
+  return Response::OK();
+}
+
 Response ServiceWorkerHandler::StopWorker(const std::string& version_id) {
   if (!enabled_)
     return Response::OK();
@@ -559,6 +586,15 @@ void ServiceWorkerHandler::WorkerReadyForInspection(
   UpdateHosts();
 }
 
+void ServiceWorkerHandler::WorkerVersionInstalled(
+    ServiceWorkerDevToolsAgentHost* host) {
+  UpdateHosts();
+}
+void ServiceWorkerHandler::WorkerVersionDoomed(
+    ServiceWorkerDevToolsAgentHost* host) {
+  UpdateHosts();
+}
+
 void ServiceWorkerHandler::WorkerDestroyed(
     ServiceWorkerDevToolsAgentHost* host) {
   UpdateHosts();
diff --git a/chromium/content/browser/devtools/protocol/service_worker_handler.h b/chromium/content/browser/devtools/protocol/service_worker_handler.h
index 02dcd8c43f5..cf875370d52 100644
--- a/chromium/content/browser/devtools/protocol/service_worker_handler.h
+++ b/chromium/content/browser/devtools/protocol/service_worker_handler.h
@@ -42,7 +42,7 @@ class ServiceWorkerHandler : public DevToolsAgentHostClient,
   ~ServiceWorkerHandler() override;
 
   void SetRenderFrameHost(RenderFrameHostImpl* render_frame_host);
-  void SetClient(scoped_ptr<Client> client);
+  void SetClient(std::unique_ptr<Client> client);
   void UpdateHosts();
   void Detached();
 
@@ -54,6 +54,7 @@ class ServiceWorkerHandler : public DevToolsAgentHostClient,
   Response Stop(const std::string& worker_id);
   Response Unregister(const std::string& scope_url);
   Response StartWorker(const std::string& scope_url);
+  Response SkipWaiting(const std::string& scope_url);
   Response StopWorker(const std::string& version_id);
   Response UpdateRegistration(const std::string& scope_url);
   Response InspectWorker(const std::string& version_id);
@@ -68,6 +69,8 @@ class ServiceWorkerHandler : public DevToolsAgentHostClient,
   // WorkerDevToolsManager::Observer implementation.
   void WorkerCreated(ServiceWorkerDevToolsAgentHost* host) override;
   void WorkerReadyForInspection(ServiceWorkerDevToolsAgentHost* host) override;
+  void WorkerVersionInstalled(ServiceWorkerDevToolsAgentHost* host) override;
+  void WorkerVersionDoomed(ServiceWorkerDevToolsAgentHost* host) override;
   void WorkerDestroyed(ServiceWorkerDevToolsAgentHost* host) override;
 
  private:
@@ -92,7 +95,7 @@ class ServiceWorkerHandler : public DevToolsAgentHostClient,
   void ClearForceUpdate();
 
   scoped_refptr<ServiceWorkerContextWrapper> context_;
-  scoped_ptr<Client> client_;
+  std::unique_ptr<Client> client_;
   ServiceWorkerDevToolsAgentHost::Map attached_hosts_;
   bool enabled_;
   std::set<GURL> urls_;
diff --git a/chromium/content/browser/devtools/protocol/storage_handler.cc b/chromium/content/browser/devtools/protocol/storage_handler.cc
new file mode 100644
index 00000000000..c9e7a0505d8
--- /dev/null
+++ b/chromium/content/browser/devtools/protocol/storage_handler.cc
@@ -0,0 +1,95 @@
+// Copyright 2016 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/protocol/storage_handler.h"
+
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+#include "base/strings/string_split.h"
+#include "content/browser/devtools/protocol/devtools_protocol_dispatcher.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/storage_partition.h"
+
+namespace content {
+namespace devtools {
+namespace storage {
+
+namespace {
+static const char kAppCache[] = "appcache";
+static const char kCookies[] = "cookies";
+static const char kFileSystems[] = "filesystems";
+static const char kIndexedDB[] = "indexeddb";
+static const char kLocalStorage[] = "local_storage";
+static const char kShaderCache[] = "shader_cache";
+static const char kWebSQL[] = "websql";
+static const char kWebRTCIdentity[] = "webrdc_identity";
+static const char kServiceWorkers[] = "service_workers";
+static const char kCacheStorage[] = "cache_storage";
+static const char kAll[] = "all";
+}
+
+typedef DevToolsProtocolClient::Response Response;
+
+StorageHandler::StorageHandler()
+    : host_(nullptr) {
+}
+
+StorageHandler::~StorageHandler() = default;
+
+void StorageHandler::SetRenderFrameHost(RenderFrameHost* host) {
+  host_ = host;
+}
+
+Response StorageHandler::ClearDataForOrigin(
+    const std::string& origin,
+    const std::string& storage_types) {
+  if (!host_)
+    return Response::InternalError("Not connected to host");
+
+  StoragePartition* partition = host_->GetProcess()->GetStoragePartition();
+  std::vector<std::string> types = base::SplitString(
+      storage_types, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+  std::unordered_set<std::string> set(types.begin(), types.end());
+  uint32_t remove_mask = 0;
+  if (set.count(kAppCache))
+    remove_mask |= StoragePartition::REMOVE_DATA_MASK_APPCACHE;
+  if (set.count(kCookies))
+    remove_mask |= StoragePartition::REMOVE_DATA_MASK_COOKIES;
+  if (set.count(kFileSystems))
+    remove_mask |= StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS;
+  if (set.count(kIndexedDB))
+    remove_mask |= StoragePartition::REMOVE_DATA_MASK_INDEXEDDB;
+  if (set.count(kLocalStorage))
+    remove_mask |= StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE;
+  if (set.count(kShaderCache))
+    remove_mask |= StoragePartition::REMOVE_DATA_MASK_SHADER_CACHE;
+  if (set.count(kWebSQL))
+    remove_mask |= StoragePartition::REMOVE_DATA_MASK_WEBSQL;
+  if (set.count(kWebRTCIdentity))
+    remove_mask |= StoragePartition::REMOVE_DATA_MASK_WEBRTC_IDENTITY;
+  if (set.count(kServiceWorkers))
+    remove_mask |= StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS;
+  if (set.count(kCacheStorage))
+    remove_mask |= StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE;
+  if (set.count(kAll))
+    remove_mask |= StoragePartition::REMOVE_DATA_MASK_ALL;
+
+  if (!remove_mask)
+    return Response::InvalidParams("No valid storage type specified");
+
+  partition->ClearDataForOrigin(
+      remove_mask,
+      StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL,
+      GURL(origin),
+      partition->GetURLRequestContext(),
+      base::Bind(&base::DoNothing));
+  return Response::OK();
+}
+
+}  // namespace storage
+}  // namespace devtools
+}  // namespace content
diff --git a/chromium/content/browser/devtools/protocol/storage_handler.h b/chromium/content/browser/devtools/protocol/storage_handler.h
new file mode 100644
index 00000000000..d6f7c65bb35
--- /dev/null
+++ b/chromium/content/browser/devtools/protocol/storage_handler.h
@@ -0,0 +1,42 @@
+// Copyright 2016 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.
+
+#ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_STORAGE_HANDLER_H_
+#define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_STORAGE_HANDLER_H_
+
+#include "base/macros.h"
+#include "content/browser/devtools/devtools_protocol_handler.h"
+#include "content/browser/devtools/protocol/devtools_protocol_dispatcher.h"
+
+namespace content {
+
+class RenderFrameHost;
+
+namespace devtools {
+namespace storage {
+
+class StorageHandler {
+ public:
+  typedef DevToolsProtocolClient::Response Response;
+
+  StorageHandler();
+  ~StorageHandler();
+
+  void SetRenderFrameHost(RenderFrameHost* host);
+
+  Response ClearDataForOrigin(
+      const std::string& origin,
+      const std::string& storage_types);
+
+ private:
+  RenderFrameHost* host_;
+
+  DISALLOW_COPY_AND_ASSIGN(StorageHandler);
+};
+
+}  // namespace storage
+}  // namespace devtools
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_STORAGE_HANDLER_H_
diff --git a/chromium/content/browser/devtools/protocol/system_info_handler.cc b/chromium/content/browser/devtools/protocol/system_info_handler.cc
index 5a9d53ad1e9..2c139c422eb 100644
--- a/chromium/content/browser/devtools/protocol/system_info_handler.cc
+++ b/chromium/content/browser/devtools/protocol/system_info_handler.cc
@@ -5,10 +5,12 @@
 #include "content/browser/devtools/protocol/system_info_handler.h"
 
 #include <stdint.h>
+
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/memory/ptr_util.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "gpu/config/gpu_feature_type.h"
@@ -145,7 +147,7 @@ SystemInfoHandler::SystemInfoHandler()
 SystemInfoHandler::~SystemInfoHandler() {
 }
 
-void SystemInfoHandler::SetClient(scoped_ptr<Client> client) {
+void SystemInfoHandler::SetClient(std::unique_ptr<Client> client) {
   client_.swap(client);
 }
 
@@ -197,7 +199,8 @@ void SystemInfoHandler::SendGetInfoResponse(DevToolsCommandId command_id) {
   for (const auto& device : gpu_info.secondary_gpus)
     devices.push_back(GPUDeviceToProtocol(device));
 
-  scoped_ptr<base::DictionaryValue> aux_attributes(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> aux_attributes(
+      new base::DictionaryValue);
   AuxGPUInfoEnumerator enumerator(aux_attributes.get());
   gpu_info.EnumerateFields(&enumerator);
 
@@ -205,7 +208,7 @@ void SystemInfoHandler::SendGetInfoResponse(DevToolsCommandId command_id) {
       GPUInfo::Create()
           ->set_devices(devices)
           ->set_aux_attributes(std::move(aux_attributes))
-          ->set_feature_status(make_scoped_ptr(GetFeatureStatus()))
+          ->set_feature_status(base::WrapUnique(GetFeatureStatus()))
           ->set_driver_bug_workarounds(GetDriverBugWorkarounds());
 
   client_->SendGetInfoResponse(
diff --git a/chromium/content/browser/devtools/protocol/system_info_handler.h b/chromium/content/browser/devtools/protocol/system_info_handler.h
index 40b14e8e3c4..281d08bbc95 100644
--- a/chromium/content/browser/devtools/protocol/system_info_handler.h
+++ b/chromium/content/browser/devtools/protocol/system_info_handler.h
@@ -23,7 +23,7 @@ class SystemInfoHandler {
   SystemInfoHandler();
   ~SystemInfoHandler();
 
-  void SetClient(scoped_ptr<Client> client);
+  void SetClient(std::unique_ptr<Client> client);
 
   Response GetInfo(DevToolsCommandId command_id);
 
@@ -47,7 +47,7 @@ class SystemInfoHandler {
   mutable base::Lock lock_;
   std::set<int> active_observers_;
 
-  scoped_ptr<Client> client_;
+  std::unique_ptr<Client> client_;
   base::WeakPtrFactory<SystemInfoHandler> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SystemInfoHandler);
diff --git a/chromium/content/browser/devtools/protocol/tethering_handler.cc b/chromium/content/browser/devtools/protocol/tethering_handler.cc
index 1718261c355..5d07f60a9ac 100644
--- a/chromium/content/browser/devtools/protocol/tethering_handler.cc
+++ b/chromium/content/browser/devtools/protocol/tethering_handler.cc
@@ -27,7 +27,7 @@ const int kMaxTetheringPort = 32767;
 
 using Response = DevToolsProtocolClient::Response;
 using CreateServerSocketCallback =
-    base::Callback<scoped_ptr<net::ServerSocket>(std::string*)>;
+    base::Callback<std::unique_ptr<net::ServerSocket>(std::string*)>;
 
 class SocketPump {
  public:
@@ -146,9 +146,9 @@ class SocketPump {
 
 
  private:
-  scoped_ptr<net::StreamSocket> client_socket_;
-  scoped_ptr<net::ServerSocket> server_socket_;
-  scoped_ptr<net::StreamSocket> accepted_socket_;
+  std::unique_ptr<net::StreamSocket> client_socket_;
+  std::unique_ptr<net::ServerSocket> server_socket_;
+  std::unique_ptr<net::StreamSocket> accepted_socket_;
   int pending_writes_;
   bool pending_destruction_;
 };
@@ -217,8 +217,8 @@ class BoundSocket {
 
   AcceptedCallback accepted_callback_;
   CreateServerSocketCallback socket_callback_;
-  scoped_ptr<net::ServerSocket> socket_;
-  scoped_ptr<net::StreamSocket> accept_socket_;
+  std::unique_ptr<net::ServerSocket> socket_;
+  std::unique_ptr<net::StreamSocket> accept_socket_;
   uint16_t port_;
 };
 
@@ -268,7 +268,7 @@ void TetheringHandler::TetheringImpl::Bind(DevToolsCommandId command_id,
 
   BoundSocket::AcceptedCallback callback = base::Bind(
       &TetheringHandler::TetheringImpl::Accepted, base::Unretained(this));
-  scoped_ptr<BoundSocket> bound_socket(
+  std::unique_ptr<BoundSocket> bound_socket(
       new BoundSocket(callback, socket_callback_));
   if (!bound_socket->Listen(port)) {
     SendInternalError(command_id, "Could not bind port");
@@ -338,7 +338,7 @@ TetheringHandler::~TetheringHandler() {
   }
 }
 
-void TetheringHandler::SetClient(scoped_ptr<Client> client) {
+void TetheringHandler::SetClient(std::unique_ptr<Client> client) {
   client_.swap(client);
 }
 
diff --git a/chromium/content/browser/devtools/protocol/tethering_handler.h b/chromium/content/browser/devtools/protocol/tethering_handler.h
index fc6b8e50673..f45ac9cdd35 100644
--- a/chromium/content/browser/devtools/protocol/tethering_handler.h
+++ b/chromium/content/browser/devtools/protocol/tethering_handler.h
@@ -24,13 +24,13 @@ class TetheringHandler {
  public:
   using Response = DevToolsProtocolClient::Response;
   using CreateServerSocketCallback =
-      base::Callback<scoped_ptr<net::ServerSocket>(std::string*)>;
+      base::Callback<std::unique_ptr<net::ServerSocket>(std::string*)>;
 
   TetheringHandler(const CreateServerSocketCallback& socket_callback,
                    scoped_refptr<base::SingleThreadTaskRunner> task_runner);
   ~TetheringHandler();
 
-  void SetClient(scoped_ptr<Client> client);
+  void SetClient(std::unique_ptr<Client> client);
 
   Response Bind(DevToolsCommandId command_id, int port);
   Response Unbind(DevToolsCommandId command_id, int port);
@@ -46,7 +46,7 @@ class TetheringHandler {
   void SendInternalError(DevToolsCommandId command_id,
                          const std::string& message);
 
-  scoped_ptr<Client> client_;
+  std::unique_ptr<Client> client_;
   CreateServerSocketCallback socket_callback_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   bool is_active_;
diff --git a/chromium/content/browser/devtools/protocol/tracing_handler.cc b/chromium/content/browser/devtools/protocol/tracing_handler.cc
index e7de4c753ce..59cbfc9e0a1 100644
--- a/chromium/content/browser/devtools/protocol/tracing_handler.cc
+++ b/chromium/content/browser/devtools/protocol/tracing_handler.cc
@@ -48,10 +48,11 @@ std::string ConvertFromCamelCase(const std::string& in_str, char separator) {
   return out_str;
 }
 
-scoped_ptr<base::Value> ConvertDictKeyStyle(const base::Value& value) {
+std::unique_ptr<base::Value> ConvertDictKeyStyle(const base::Value& value) {
   const base::DictionaryValue* dict = nullptr;
   if (value.GetAsDictionary(&dict)) {
-    scoped_ptr<base::DictionaryValue> out_dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> out_dict(
+        new base::DictionaryValue());
     for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd();
          it.Advance()) {
       out_dict->Set(ConvertFromCamelCase(it.key(), '_'),
@@ -62,7 +63,7 @@ scoped_ptr<base::Value> ConvertDictKeyStyle(const base::Value& value) {
 
   const base::ListValue* list = nullptr;
   if (value.GetAsList(&list)) {
-    scoped_ptr<base::ListValue> out_list(new base::ListValue());
+    std::unique_ptr<base::ListValue> out_list(new base::ListValue());
     for (const auto& value : *list)
       out_list->Append(ConvertDictKeyStyle(*value));
     return std::move(out_list);
@@ -141,7 +142,7 @@ TracingHandler::TracingHandler(TracingHandler::Target target,
 TracingHandler::~TracingHandler() {
 }
 
-void TracingHandler::SetClient(scoped_ptr<Client> client) {
+void TracingHandler::SetClient(std::unique_ptr<Client> client) {
   client_.swap(client);
 }
 
@@ -177,7 +178,7 @@ Response TracingHandler::Start(
     const std::string* options,
     const double* buffer_usage_reporting_interval,
     const std::string* transfer_mode,
-    const scoped_ptr<base::DictionaryValue>& config) {
+    const std::unique_ptr<base::DictionaryValue>& config) {
   if (IsTracing())
     return Response::InternalError("Tracing is already started");
 
@@ -339,9 +340,9 @@ bool TracingHandler::IsStartupTracingActive() {
 // static
 base::trace_event::TraceConfig TracingHandler::GetTraceConfigFromDevToolsConfig(
     const base::DictionaryValue& devtools_config) {
-  scoped_ptr<base::Value> value = ConvertDictKeyStyle(devtools_config);
+  std::unique_ptr<base::Value> value = ConvertDictKeyStyle(devtools_config);
   DCHECK(value && value->IsType(base::Value::TYPE_DICTIONARY));
-  scoped_ptr<base::DictionaryValue> tracing_dict(
+  std::unique_ptr<base::DictionaryValue> tracing_dict(
       static_cast<base::DictionaryValue*>(value.release()));
 
   std::string mode;
diff --git a/chromium/content/browser/devtools/protocol/tracing_handler.h b/chromium/content/browser/devtools/protocol/tracing_handler.h
index be3e6e412ed..019cd9c3ebb 100644
--- a/chromium/content/browser/devtools/protocol/tracing_handler.h
+++ b/chromium/content/browser/devtools/protocol/tracing_handler.h
@@ -41,7 +41,7 @@ class TracingHandler {
                  DevToolsIOContext* io_context);
   virtual ~TracingHandler();
 
-  void SetClient(scoped_ptr<Client> client);
+  void SetClient(std::unique_ptr<Client> client);
   void Detached();
 
   void OnTraceDataCollected(const std::string& trace_fragment);
@@ -54,7 +54,7 @@ class TracingHandler {
                  const std::string* options,
                  const double* buffer_usage_reporting_interval,
                  const std::string* transfer_mode,
-                 const scoped_ptr<base::DictionaryValue>& config);
+                 const std::unique_ptr<base::DictionaryValue>& config);
   Response End(DevToolsCommandId command_id);
   Response GetCategories(DevToolsCommandId command);
   Response RequestMemoryDump(DevToolsCommandId command_id);
@@ -80,10 +80,10 @@ class TracingHandler {
       GetTraceConfigFromDevToolsConfig(
           const base::DictionaryValue& devtools_config);
 
-  scoped_ptr<base::Timer> buffer_usage_poll_timer_;
+  std::unique_ptr<base::Timer> buffer_usage_poll_timer_;
   Target target_;
 
-  scoped_ptr<Client> client_;
+  std::unique_ptr<Client> client_;
   DevToolsIOContext* io_context_;
   int frame_tree_node_id_;
   bool did_initiate_recording_;
diff --git a/chromium/content/browser/devtools/protocol/tracing_handler_unittest.cc b/chromium/content/browser/devtools/protocol/tracing_handler_unittest.cc
index 8182f45826f..85b01d883ab 100644
--- a/chromium/content/browser/devtools/protocol/tracing_handler_unittest.cc
+++ b/chromium/content/browser/devtools/protocol/tracing_handler_unittest.cc
@@ -57,9 +57,9 @@ const char kCustomTraceConfigStringDevToolsStyle[] =
 }
 
 TEST(TracingHandlerTest, GetTraceConfigFromDevToolsConfig) {
-  scoped_ptr<base::Value> value = base::JSONReader::Read(
-      kCustomTraceConfigStringDevToolsStyle);
-  scoped_ptr<base::DictionaryValue> devtools_style_dict(
+  std::unique_ptr<base::Value> value =
+      base::JSONReader::Read(kCustomTraceConfigStringDevToolsStyle);
+  std::unique_ptr<base::DictionaryValue> devtools_style_dict(
       static_cast<base::DictionaryValue*>(value.release()));
 
   base::trace_event::TraceConfig trace_config =
diff --git a/chromium/content/browser/devtools/render_frame_devtools_agent_host.cc b/chromium/content/browser/devtools/render_frame_devtools_agent_host.cc
index d9a1a1c0b0d..f2aaf547399 100644
--- a/chromium/content/browser/devtools/render_frame_devtools_agent_host.cc
+++ b/chromium/content/browser/devtools/render_frame_devtools_agent_host.cc
@@ -21,6 +21,7 @@
 #include "content/browser/devtools/protocol/page_handler.h"
 #include "content/browser/devtools/protocol/security_handler.h"
 #include "content/browser/devtools/protocol/service_worker_handler.h"
+#include "content/browser/devtools/protocol/storage_handler.h"
 #include "content/browser/devtools/protocol/tracing_handler.h"
 #include "content/browser/frame_host/navigation_handle_impl.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
@@ -98,6 +99,7 @@ class RenderFrameDevToolsAgentHost::FrameHostHolder {
   void Detach();
   void DispatchProtocolMessage(int session_id,
                                int call_id,
+                               const std::string& method,
                                const std::string& message);
   void InspectElement(int x, int y);
   void ProcessChunkedMessageFromAgent(const DevToolsMessageChunk& chunk);
@@ -116,8 +118,8 @@ class RenderFrameDevToolsAgentHost::FrameHostHolder {
   DevToolsMessageChunkProcessor chunk_processor_;
   // <session_id, message>
   std::vector<std::pair<int, std::string>> pending_messages_;
-  // <call_id> -> <session_id, message>
-  std::map<int, std::pair<int, std::string>> sent_messages_;
+  // <call_id> -> PendingMessage
+  std::map<int, PendingMessage> sent_messages_;
 };
 
 RenderFrameDevToolsAgentHost::FrameHostHolder::FrameHostHolder(
@@ -154,8 +156,8 @@ void RenderFrameDevToolsAgentHost::FrameHostHolder::Reattach(
       chunk_processor_.state_cookie()));
   if (old) {
     for (const auto& pair : old->sent_messages_) {
-      DispatchProtocolMessage(pair.second.first, pair.first,
-                              pair.second.second);
+      DispatchProtocolMessage(pair.second.session_id, pair.first,
+                              pair.second.method, pair.second.message);
     }
   }
   GrantPolicy();
@@ -198,10 +200,11 @@ void RenderFrameDevToolsAgentHost::FrameHostHolder::RevokePolicy() {
 void RenderFrameDevToolsAgentHost::FrameHostHolder::DispatchProtocolMessage(
     int session_id,
     int call_id,
+    const std::string& method,
     const std::string& message) {
   host_->Send(new DevToolsAgentMsg_DispatchOnInspectorBackend(
-      host_->GetRoutingID(), session_id, message));
-  sent_messages_[call_id] = std::make_pair(session_id, message);
+      host_->GetRoutingID(), session_id, call_id, method, message));
+  sent_messages_[call_id] = { session_id, method, message };
 }
 
 void RenderFrameDevToolsAgentHost::FrameHostHolder::InspectElement(
@@ -351,6 +354,7 @@ RenderFrameDevToolsAgentHost::RenderFrameDevToolsAgentHost(
       security_handler_(nullptr),
       service_worker_handler_(
           new devtools::service_worker::ServiceWorkerHandler()),
+      storage_handler_(new devtools::storage::StorageHandler()),
       tracing_handler_(new devtools::tracing::TracingHandler(
           devtools::tracing::TracingHandler::Renderer,
           host->GetFrameTreeNodeId(),
@@ -368,6 +372,7 @@ RenderFrameDevToolsAgentHost::RenderFrameDevToolsAgentHost(
   dispatcher->SetIOHandler(io_handler_.get());
   dispatcher->SetNetworkHandler(network_handler_.get());
   dispatcher->SetServiceWorkerHandler(service_worker_handler_.get());
+  dispatcher->SetStorageHandler(storage_handler_.get());
   dispatcher->SetTracingHandler(tracing_handler_.get());
 
   if (!host->GetParent()) {
@@ -459,20 +464,22 @@ void RenderFrameDevToolsAgentHost::Detach() {
 bool RenderFrameDevToolsAgentHost::DispatchProtocolMessage(
     const std::string& message) {
   int call_id = 0;
-  if (protocol_handler_->HandleOptionalMessage(session_id(), message, &call_id))
+  std::string method;
+  if (protocol_handler_->HandleOptionalMessage(session_id(), message, &call_id,
+                                               &method))
     return true;
 
   if (!navigating_handles_.empty()) {
     DCHECK(IsBrowserSideNavigationEnabled());
     in_navigation_protocol_message_buffer_[call_id] =
-        std::make_pair(session_id(), message);
+        { session_id(), method, message };
     return true;
   }
 
   if (current_)
-    current_->DispatchProtocolMessage(session_id(), call_id, message);
+    current_->DispatchProtocolMessage(session_id(), call_id, method, message);
   if (pending_)
-    pending_->DispatchProtocolMessage(session_id(), call_id, message);
+    pending_->DispatchProtocolMessage(session_id(), call_id, method, message);
   return true;
 }
 
@@ -746,8 +753,9 @@ void RenderFrameDevToolsAgentHost::
       in_navigation_protocol_message_buffer_.size()) {
     DCHECK(current_);
     for (const auto& pair : in_navigation_protocol_message_buffer_) {
-      current_->DispatchProtocolMessage(pair.second.first, pair.first,
-                                        pair.second.second);
+      current_->DispatchProtocolMessage(
+          pair.second.session_id, pair.first, pair.second.method,
+          pair.second.message);
     }
     in_navigation_protocol_message_buffer_.clear();
   }
@@ -767,6 +775,8 @@ void RenderFrameDevToolsAgentHost::UpdateProtocolHandlers(
   service_worker_handler_->SetRenderFrameHost(host);
   if (security_handler_)
     security_handler_->SetRenderFrameHost(host);
+  if (storage_handler_)
+    storage_handler_->SetRenderFrameHost(host);
 }
 
 void RenderFrameDevToolsAgentHost::DisconnectWebContents() {
diff --git a/chromium/content/browser/devtools/render_frame_devtools_agent_host.h b/chromium/content/browser/devtools/render_frame_devtools_agent_host.h
index 24d05358ad9..e6cc44024d0 100644
--- a/chromium/content/browser/devtools/render_frame_devtools_agent_host.h
+++ b/chromium/content/browser/devtools/render_frame_devtools_agent_host.h
@@ -6,10 +6,10 @@
 #define CONTENT_BROWSER_DEVTOOLS_RENDER_FRAME_DEVTOOLS_AGENT_HOST_H_
 
 #include <map>
+#include <memory>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
 #include "content/browser/devtools/devtools_agent_host_impl.h"
 #include "content/common/content_export.h"
@@ -42,6 +42,7 @@ namespace network { class NetworkHandler; }
 namespace page { class PageHandler; }
 namespace security { class SecurityHandler; }
 namespace service_worker { class ServiceWorkerHandler; }
+namespace storage { class StorageHandler; }
 namespace tracing { class TracingHandler; }
 }
 
@@ -142,28 +143,30 @@ class CONTENT_EXPORT RenderFrameDevToolsAgentHost
 
   class FrameHostHolder;
 
-  scoped_ptr<FrameHostHolder> current_;
-  scoped_ptr<FrameHostHolder> pending_;
+  std::unique_ptr<FrameHostHolder> current_;
+  std::unique_ptr<FrameHostHolder> pending_;
 
   // Stores per-host state between DisconnectWebContents and ConnectWebContents.
-  scoped_ptr<FrameHostHolder> disconnected_;
-
-  scoped_ptr<devtools::dom::DOMHandler> dom_handler_;
-  scoped_ptr<devtools::input::InputHandler> input_handler_;
-  scoped_ptr<devtools::inspector::InspectorHandler> inspector_handler_;
-  scoped_ptr<devtools::io::IOHandler> io_handler_;
-  scoped_ptr<devtools::network::NetworkHandler> network_handler_;
-  scoped_ptr<devtools::page::PageHandler> page_handler_;
-  scoped_ptr<devtools::security::SecurityHandler> security_handler_;
-  scoped_ptr<devtools::service_worker::ServiceWorkerHandler>
+  std::unique_ptr<FrameHostHolder> disconnected_;
+
+  std::unique_ptr<devtools::dom::DOMHandler> dom_handler_;
+  std::unique_ptr<devtools::input::InputHandler> input_handler_;
+  std::unique_ptr<devtools::inspector::InspectorHandler> inspector_handler_;
+  std::unique_ptr<devtools::io::IOHandler> io_handler_;
+  std::unique_ptr<devtools::network::NetworkHandler> network_handler_;
+  std::unique_ptr<devtools::page::PageHandler> page_handler_;
+  std::unique_ptr<devtools::security::SecurityHandler> security_handler_;
+  std::unique_ptr<devtools::service_worker::ServiceWorkerHandler>
       service_worker_handler_;
-  scoped_ptr<devtools::tracing::TracingHandler> tracing_handler_;
-  scoped_ptr<devtools::emulation::EmulationHandler> emulation_handler_;
-  scoped_ptr<DevToolsFrameTraceRecorder> frame_trace_recorder_;
+  std::unique_ptr<devtools::storage::StorageHandler>
+      storage_handler_;
+  std::unique_ptr<devtools::tracing::TracingHandler> tracing_handler_;
+  std::unique_ptr<devtools::emulation::EmulationHandler> emulation_handler_;
+  std::unique_ptr<DevToolsFrameTraceRecorder> frame_trace_recorder_;
 #if defined(OS_ANDROID)
-  scoped_ptr<PowerSaveBlockerImpl> power_save_blocker_;
+  std::unique_ptr<PowerSaveBlockerImpl> power_save_blocker_;
 #endif
-  scoped_ptr<DevToolsProtocolHandler> protocol_handler_;
+  std::unique_ptr<DevToolsProtocolHandler> protocol_handler_;
   bool current_frame_crashed_;
 
   // PlzNavigate
@@ -174,9 +177,13 @@ class CONTENT_EXPORT RenderFrameDevToolsAgentHost
   // List of handles currently navigating.
   std::set<NavigationHandle*> navigating_handles_;
 
-  // <call_id> -> <session_id, message>
-  std::map<int, std::pair<int, std::string>>
-      in_navigation_protocol_message_buffer_;
+  struct PendingMessage {
+    int session_id;
+    std::string method;
+    std::string message;
+  };
+  // <call_id> -> PendingMessage
+  std::map<int, PendingMessage> in_navigation_protocol_message_buffer_;
 
   // The FrameTreeNode associated with this agent.
   FrameTreeNode* frame_tree_node_;
diff --git a/chromium/content/browser/devtools/service_worker_devtools_agent_host.cc b/chromium/content/browser/devtools/service_worker_devtools_agent_host.cc
index 33293d52e5b..d44ea7e1e70 100644
--- a/chromium/content/browser/devtools/service_worker_devtools_agent_host.cc
+++ b/chromium/content/browser/devtools/service_worker_devtools_agent_host.cc
@@ -54,10 +54,13 @@ void SetDevToolsAttachedOnIO(
 
 ServiceWorkerDevToolsAgentHost::ServiceWorkerDevToolsAgentHost(
     WorkerId worker_id,
-    const ServiceWorkerIdentifier& service_worker)
+    const ServiceWorkerIdentifier& service_worker,
+    bool is_installed_version)
     : WorkerDevToolsAgentHost(worker_id),
       service_worker_(new ServiceWorkerIdentifier(service_worker)),
-      network_handler_(new devtools::network::NetworkHandler()) {
+      network_handler_(new devtools::network::NetworkHandler()),
+      version_installed_time_(is_installed_version ? base::Time::Now()
+                                                   : base::Time()) {
   DevToolsProtocolDispatcher* dispatcher = protocol_handler()->dispatcher();
   dispatcher->SetNetworkHandler(network_handler_.get());
 }
@@ -105,6 +108,14 @@ void ServiceWorkerDevToolsAgentHost::OnAttachedStateChanged(bool attached) {
                   attached));
 }
 
+void ServiceWorkerDevToolsAgentHost::WorkerVersionInstalled() {
+  version_installed_time_ = base::Time::Now();
+}
+
+void ServiceWorkerDevToolsAgentHost::WorkerVersionDoomed() {
+  version_doomed_time_ = base::Time::Now();
+}
+
 int64_t ServiceWorkerDevToolsAgentHost::service_worker_version_id() const {
   return service_worker_->version_id();
 }
diff --git a/chromium/content/browser/devtools/service_worker_devtools_agent_host.h b/chromium/content/browser/devtools/service_worker_devtools_agent_host.h
index a5f15ee7dc8..9ff92960d0a 100644
--- a/chromium/content/browser/devtools/service_worker_devtools_agent_host.h
+++ b/chromium/content/browser/devtools/service_worker_devtools_agent_host.h
@@ -10,6 +10,7 @@
 #include <map>
 
 #include "base/macros.h"
+#include "base/time/time.h"
 #include "content/browser/devtools/protocol/network_handler.h"
 #include "content/browser/devtools/service_worker_devtools_manager.h"
 #include "content/browser/devtools/worker_devtools_agent_host.h"
@@ -25,7 +26,8 @@ class ServiceWorkerDevToolsAgentHost : public WorkerDevToolsAgentHost {
       ServiceWorkerDevToolsManager::ServiceWorkerIdentifier;
 
   ServiceWorkerDevToolsAgentHost(WorkerId worker_id,
-                                 const ServiceWorkerIdentifier& service_worker);
+                                 const ServiceWorkerIdentifier& service_worker,
+                                 bool is_installed_version);
 
   void UnregisterWorker();
 
@@ -39,15 +41,28 @@ class ServiceWorkerDevToolsAgentHost : public WorkerDevToolsAgentHost {
   // WorkerDevToolsAgentHost overrides.
   void OnAttachedStateChanged(bool attached) override;
 
+  void WorkerVersionInstalled();
+  void WorkerVersionDoomed();
+
   int64_t service_worker_version_id() const;
   GURL scope() const;
 
+  // If the ServiceWorker has been installed before the worker instance started,
+  // it returns the time when the instance started. Otherwise returns the time
+  // when the ServiceWorker was installed.
+  base::Time version_installed_time() const { return version_installed_time_; }
+
+  // Returns the time when the ServiceWorker was doomed.
+  base::Time version_doomed_time() const { return version_doomed_time_; }
+
   bool Matches(const ServiceWorkerIdentifier& other);
 
  private:
   ~ServiceWorkerDevToolsAgentHost() override;
-  scoped_ptr<ServiceWorkerIdentifier> service_worker_;
-  scoped_ptr<devtools::network::NetworkHandler> network_handler_;
+  std::unique_ptr<ServiceWorkerIdentifier> service_worker_;
+  std::unique_ptr<devtools::network::NetworkHandler> network_handler_;
+  base::Time version_installed_time_;
+  base::Time version_doomed_time_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerDevToolsAgentHost);
 };
diff --git a/chromium/content/browser/devtools/service_worker_devtools_manager.cc b/chromium/content/browser/devtools/service_worker_devtools_manager.cc
index 6796b71db69..2afa2ca11c8 100644
--- a/chromium/content/browser/devtools/service_worker_devtools_manager.cc
+++ b/chromium/content/browser/devtools/service_worker_devtools_manager.cc
@@ -78,14 +78,15 @@ void ServiceWorkerDevToolsManager::AddAllAgentHostsForBrowserContext(
 bool ServiceWorkerDevToolsManager::WorkerCreated(
     int worker_process_id,
     int worker_route_id,
-    const ServiceWorkerIdentifier& service_worker_id) {
+    const ServiceWorkerIdentifier& service_worker_id,
+    bool is_installed_version) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   const WorkerId id(worker_process_id, worker_route_id);
   AgentHostMap::iterator it = FindExistingWorkerAgentHost(service_worker_id);
   if (it == workers_.end()) {
     scoped_refptr<ServiceWorkerDevToolsAgentHost> host =
-        new ServiceWorkerDevToolsAgentHost(
-            id, service_worker_id);
+        new ServiceWorkerDevToolsAgentHost(id, service_worker_id,
+                                           is_installed_version);
     workers_[id] = host.get();
     FOR_EACH_OBSERVER(Observer, observer_list_, WorkerCreated(host.get()));
     if (debug_service_worker_on_start_)
@@ -122,6 +123,31 @@ void ServiceWorkerDevToolsManager::WorkerReadyForInspection(
   }
 }
 
+void ServiceWorkerDevToolsManager::WorkerVersionInstalled(int worker_process_id,
+                                                          int worker_route_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  const WorkerId id(worker_process_id, worker_route_id);
+  AgentHostMap::iterator it = workers_.find(id);
+  if (it == workers_.end())
+    return;
+  scoped_refptr<ServiceWorkerDevToolsAgentHost> host = it->second;
+  host->WorkerVersionInstalled();
+  FOR_EACH_OBSERVER(Observer, observer_list_,
+                    WorkerVersionInstalled(host.get()));
+}
+
+void ServiceWorkerDevToolsManager::WorkerVersionDoomed(int worker_process_id,
+                                                       int worker_route_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  const WorkerId id(worker_process_id, worker_route_id);
+  AgentHostMap::iterator it = workers_.find(id);
+  if (it == workers_.end())
+    return;
+  scoped_refptr<ServiceWorkerDevToolsAgentHost> host = it->second;
+  host->WorkerVersionDoomed();
+  FOR_EACH_OBSERVER(Observer, observer_list_, WorkerVersionDoomed(host.get()));
+}
+
 void ServiceWorkerDevToolsManager::WorkerStopIgnored(int worker_process_id,
                                                       int worker_route_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
diff --git a/chromium/content/browser/devtools/service_worker_devtools_manager.h b/chromium/content/browser/devtools/service_worker_devtools_manager.h
index c2cd08e11cc..000c7de219d 100644
--- a/chromium/content/browser/devtools/service_worker_devtools_manager.h
+++ b/chromium/content/browser/devtools/service_worker_devtools_manager.h
@@ -34,6 +34,8 @@ class CONTENT_EXPORT ServiceWorkerDevToolsManager {
     virtual void WorkerCreated(ServiceWorkerDevToolsAgentHost* host) {}
     virtual void WorkerReadyForInspection(
         ServiceWorkerDevToolsAgentHost* host) {}
+    virtual void WorkerVersionInstalled(ServiceWorkerDevToolsAgentHost* host) {}
+    virtual void WorkerVersionDoomed(ServiceWorkerDevToolsAgentHost* host) {}
     virtual void WorkerDestroyed(ServiceWorkerDevToolsAgentHost* host) {}
 
    protected:
@@ -85,8 +87,11 @@ class CONTENT_EXPORT ServiceWorkerDevToolsManager {
   // debug-on-start is enabled in chrome://serviceworker-internals.
   bool WorkerCreated(int worker_process_id,
                      int worker_route_id,
-                     const ServiceWorkerIdentifier& service_worker_id);
+                     const ServiceWorkerIdentifier& service_worker_id,
+                     bool is_installed_version);
   void WorkerReadyForInspection(int worker_process_id, int worker_route_id);
+  void WorkerVersionInstalled(int worker_process_id, int worker_route_id);
+  void WorkerVersionDoomed(int worker_process_id, int worker_route_id);
   void WorkerStopIgnored(int worker_process_id, int worker_route_id);
   void WorkerDestroyed(int worker_process_id, int worker_route_id);
   void RemoveInspectedWorkerData(WorkerId id);
diff --git a/chromium/content/browser/devtools/shared_worker_devtools_agent_host.h b/chromium/content/browser/devtools/shared_worker_devtools_agent_host.h
index 5ac6d6bae1f..742f0c77c25 100644
--- a/chromium/content/browser/devtools/shared_worker_devtools_agent_host.h
+++ b/chromium/content/browser/devtools/shared_worker_devtools_agent_host.h
@@ -32,7 +32,7 @@ class SharedWorkerDevToolsAgentHost : public WorkerDevToolsAgentHost {
   friend class SharedWorkerDevToolsManagerTest;
 
   ~SharedWorkerDevToolsAgentHost() override;
-  scoped_ptr<SharedWorkerInstance> shared_worker_;
+  std::unique_ptr<SharedWorkerInstance> shared_worker_;
 
   DISALLOW_COPY_AND_ASSIGN(SharedWorkerDevToolsAgentHost);
 };
diff --git a/chromium/content/browser/devtools/shared_worker_devtools_manager_unittest.cc b/chromium/content/browser/devtools/shared_worker_devtools_manager_unittest.cc
index c6f86d5fc23..c9c299e8e4d 100644
--- a/chromium/content/browser/devtools/shared_worker_devtools_manager_unittest.cc
+++ b/chromium/content/browser/devtools/shared_worker_devtools_manager_unittest.cc
@@ -6,16 +6,19 @@
 
 #include <stddef.h>
 
+#include <memory>
+
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/devtools/devtools_agent_host_impl.h"
 #include "content/browser/devtools/shared_worker_devtools_agent_host.h"
 #include "content/browser/shared_worker/shared_worker_instance.h"
 #include "content/browser/shared_worker/worker_storage_partition.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/storage_partition.h"
 #include "content/public/test/test_browser_context.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
@@ -47,17 +50,18 @@ class SharedWorkerDevToolsManagerTest : public testing::Test {
   typedef SharedWorkerDevToolsAgentHost::WorkerState WorkerState;
 
   SharedWorkerDevToolsManagerTest()
-      : ui_thread_(BrowserThread::UI, &message_loop_),
+      : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
         browser_context_(new TestBrowserContext()),
-        partition_(
-            new WorkerStoragePartition(browser_context_->GetRequestContext(),
-                                       NULL,
-                                       NULL,
-                                       NULL,
-                                       NULL,
-                                       NULL,
-                                       NULL,
-                                       NULL)),
+        partition_(new WorkerStoragePartition(
+            BrowserContext::GetDefaultStoragePartition(browser_context_.get())->
+                GetURLRequestContext(),
+            NULL,
+            NULL,
+            NULL,
+            NULL,
+            NULL,
+            NULL,
+            NULL)),
         partition_id_(*partition_.get()) {}
 
  protected:
@@ -89,10 +93,9 @@ class SharedWorkerDevToolsManagerTest : public testing::Test {
     EXPECT_EQ(size, manager_->workers_.size());
   }
 
-  base::MessageLoopForIO message_loop_;
-  BrowserThreadImpl ui_thread_;
-  scoped_ptr<TestBrowserContext> browser_context_;
-  scoped_ptr<WorkerStoragePartition> partition_;
+  TestBrowserThreadBundle browser_thread_bundle_;
+  std::unique_ptr<TestBrowserContext> browser_context_;
+  std::unique_ptr<WorkerStoragePartition> partition_;
   const WorkerStoragePartitionId partition_id_;
   SharedWorkerDevToolsManager* manager_;
 };
@@ -194,7 +197,8 @@ TEST_F(SharedWorkerDevToolsManagerTest, AttachTest) {
       blink::WebSharedWorkerCreationContextTypeNonsecure);
 
   // Created -> GetDevToolsAgentHost -> Register -> Started -> Destroyed
-  scoped_ptr<TestDevToolsClientHost> client_host1(new TestDevToolsClientHost());
+  std::unique_ptr<TestDevToolsClientHost> client_host1(
+      new TestDevToolsClientHost());
   CheckWorkerNotExist(2, 1);
   manager_->WorkerCreated(2, 1, instance1);
   CheckWorkerState(2, 1, WorkerState::WORKER_UNINSPECTED);
@@ -211,7 +215,8 @@ TEST_F(SharedWorkerDevToolsManagerTest, AttachTest) {
   EXPECT_EQ(agent_host1.get(), manager_->GetDevToolsAgentHostForWorker(2, 1));
 
   // Created -> Started -> GetDevToolsAgentHost -> Register -> Destroyed
-  scoped_ptr<TestDevToolsClientHost> client_host2(new TestDevToolsClientHost());
+  std::unique_ptr<TestDevToolsClientHost> client_host2(
+      new TestDevToolsClientHost());
   manager_->WorkerCreated(2, 2, instance2);
   CheckWorkerState(2, 2, WorkerState::WORKER_UNINSPECTED);
   manager_->WorkerReadyForInspection(2, 2);
@@ -270,7 +275,8 @@ TEST_F(SharedWorkerDevToolsManagerTest, ReattachTest) {
       blink::WebContentSecurityPolicyTypeReport, blink::WebAddressSpacePublic,
       browser_context_->GetResourceContext(), partition_id_,
       blink::WebSharedWorkerCreationContextTypeNonsecure);
-  scoped_ptr<TestDevToolsClientHost> client_host(new TestDevToolsClientHost());
+  std::unique_ptr<TestDevToolsClientHost> client_host(
+      new TestDevToolsClientHost());
   // Created -> GetDevToolsAgentHost -> Register -> Destroyed
   manager_->WorkerCreated(3, 1, instance);
   CheckWorkerState(3, 1, WorkerState::WORKER_UNINSPECTED);
diff --git a/chromium/content/browser/devtools/worker_devtools_agent_host.cc b/chromium/content/browser/devtools/worker_devtools_agent_host.cc
index d7be60a80c5..0673a191be0 100644
--- a/chromium/content/browser/devtools/worker_devtools_agent_host.cc
+++ b/chromium/content/browser/devtools/worker_devtools_agent_host.cc
@@ -46,12 +46,14 @@ bool WorkerDevToolsAgentHost::DispatchProtocolMessage(
     return true;
 
   int call_id;
-  if (protocol_handler_->HandleOptionalMessage(session_id(), message, &call_id))
+  std::string method;
+  if (protocol_handler_->HandleOptionalMessage(session_id(), message, &call_id,
+                                               &method))
     return true;
 
   if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id_.first)) {
     host->Send(new DevToolsAgentMsg_DispatchOnInspectorBackend(
-        worker_id_.second, session_id(), message));
+        worker_id_.second, session_id(), call_id, method, message));
   }
   return true;
 }
diff --git a/chromium/content/browser/devtools/worker_devtools_agent_host.h b/chromium/content/browser/devtools/worker_devtools_agent_host.h
index 4f21257a129..0f0f5436e41 100644
--- a/chromium/content/browser/devtools/worker_devtools_agent_host.h
+++ b/chromium/content/browser/devtools/worker_devtools_agent_host.h
@@ -65,7 +65,7 @@ class WorkerDevToolsAgentHost : public DevToolsAgentHostImpl,
   void WorkerCreated();
   void OnDispatchOnInspectorFrontend(const DevToolsMessageChunk& message);
 
-  scoped_ptr<DevToolsProtocolHandler> protocol_handler_;
+  std::unique_ptr<DevToolsProtocolHandler> protocol_handler_;
   DevToolsMessageChunkProcessor chunk_processor_;
   WorkerState state_;
   WorkerId worker_id_;