diff --git a/brightray/brightray.gyp b/brightray/brightray.gyp
index 3978a5e368d9..b5fcbbd05c07 100644
--- a/brightray/brightray.gyp
+++ b/brightray/brightray.gyp
@@ -1,7 +1,7 @@
 {
   'variables': {
     # The libraries brightray will be compiled to.
-    'linux_system_libraries': 'gtk+-2.0 dbus-1 x11 xi xcursor xdamage xrandr xcomposite xext xfixes xrender xtst gconf-2.0 gmodule-2.0 nss'
+    'linux_system_libraries': 'gtk+-2.0 dbus-1 x11 xi xcursor xdamage xrandr xcomposite xext xfixes xrender xtst xscrnsaver gconf-2.0 gmodule-2.0 nss'
   },
   'includes': [
     'filenames.gypi',
@@ -169,7 +169,9 @@
                   # media.gyp:
                   '$(SDKROOT)/System/Library/Frameworks/AudioToolbox.framework',
                   '$(SDKROOT)/System/Library/Frameworks/AudioUnit.framework',
+                  '$(SDKROOT)/System/Library/Frameworks/AVFoundation.framework',
                   '$(SDKROOT)/System/Library/Frameworks/CoreAudio.framework',
+                  '$(SDKROOT)/System/Library/Frameworks/CoreMedia.framework',
                   '$(SDKROOT)/System/Library/Frameworks/CoreMIDI.framework',
                   '$(SDKROOT)/System/Library/Frameworks/CoreVideo.framework',
                   # surface.gyp:
@@ -257,7 +259,9 @@
                   '-lmfplat.lib',
                   '-lmfuuid.lib',
                   # media.gyp:
+                  '-ldxguid.lib',
                   '-lmfreadwrite.lib',
+                  '-lmfuuid.lib',
                 ],
                 'msvs_settings': {
                   'VCLinkerTool': {
@@ -273,12 +277,27 @@
                       'usp10.lib',
                       'version.lib',
                       'winspool.lib',
+                      'wtsapi32.lib',
+                      # bluetooth.gyp:
+                      'Bthprops.lib',
+                      'BluetoothApis.lib',
                       # base.gyp:
+                      'cfgmgr32.lib',
                       'powrprof.lib',
+                      'setupapi.lib',
+                      # net_common.gypi:
+                      'crypt32.lib',
+                      'dhcpcsvc.lib',
+                      'rpcrt4.lib',
+                      'secur32.lib',
+                      'urlmon.lib',
+                      'winhttp.lib',
                     ],
                     'DelayLoadDLLs': [
+                      'wtsapi32.dll',
                       # content_common.gypi:
                       'd3d9.dll',
+                      'd3d11.dll',
                       'dxva2.dll',
                       # media.gyp:
                       'mf.dll',
@@ -289,7 +308,16 @@
                       'Bthprops.cpl',
                       'setupapi.dll',
                       # base.gyp:
+                      'cfgmgr32.dll',
                       'powrprof.dll',
+                      'setupapi.dll',
+                      # net_common.gypi:
+                      'crypt32.dll',
+                      'dhcpcsvc.dll',
+                      'rpcrt4.dll',
+                      'secur32.dll',
+                      'urlmon.dll',
+                      'winhttp.dll',
                       # windows runtime
                       'API-MS-WIN-CORE-WINRT-L1-1-0.DLL',
                       'API-MS-WIN-CORE-WINRT-STRING-L1-1-0.DLL',
diff --git a/brightray/browser/browser_client.cc b/brightray/browser/browser_client.cc
index 88c41957ae9f..4ba0caa67d92 100644
--- a/brightray/browser/browser_client.cc
+++ b/brightray/browser/browser_client.cc
@@ -68,16 +68,6 @@ content::BrowserMainParts* BrowserClient::CreateBrowserMainParts(
   return browser_main_parts_;
 }
 
-net::URLRequestContextGetter* BrowserClient::CreateRequestContext(
-    content::BrowserContext* browser_context,
-    content::ProtocolHandlerMap* protocol_handlers,
-    content::URLRequestInterceptorScopedVector protocol_interceptors) {
-  auto context = static_cast<BrowserContext*>(browser_context);
-  return context->CreateRequestContext(static_cast<NetLog*>(GetNetLog()),
-                                       protocol_handlers,
-                                       std::move(protocol_interceptors));
-}
-
 content::MediaObserver* BrowserClient::GetMediaObserver() {
   return MediaCaptureDevicesDispatcher::GetInstance();
 }
diff --git a/brightray/browser/browser_client.h b/brightray/browser/browser_client.h
index 9b7cff7fe4cf..acb12b99708b 100644
--- a/brightray/browser/browser_client.h
+++ b/brightray/browser/browser_client.h
@@ -6,13 +6,13 @@
 #define BRIGHTRAY_BROWSER_BROWSER_CLIENT_H_
 
 #include "browser/net_log.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/content_browser_client.h"
 
 namespace brightray {
 
 class BrowserContext;
 class BrowserMainParts;
-class NetLog;
 class NotificationPresenter;
 class PlatformNotificationService;
 
@@ -34,19 +34,8 @@ class BrowserClient : public content::ContentBrowserClient {
     callback.Run(true);
   }
 
- protected:
-  // Subclasses should override this to provide their own BrowserMainParts
-  // implementation. The lifetime of the returned instance is managed by the
-  // caller.
-  virtual BrowserMainParts* OverrideCreateBrowserMainParts(
-      const content::MainFunctionParams&);
-
   // Subclasses that override this (e.g., to provide their own protocol
   // handlers) should call this implementation after doing their own work.
-  net::URLRequestContextGetter* CreateRequestContext(
-      content::BrowserContext* browser_context,
-      content::ProtocolHandlerMap* protocol_handlers,
-      content::URLRequestInterceptorScopedVector protocol_interceptors) override;
   content::BrowserMainParts* CreateBrowserMainParts(
       const content::MainFunctionParams&) override;
   content::MediaObserver* GetMediaObserver() override;
@@ -57,12 +46,19 @@ class BrowserClient : public content::ContentBrowserClient {
   base::FilePath GetDefaultDownloadDirectory() override;
   content::DevToolsManagerDelegate* GetDevToolsManagerDelegate() override;
 
+ protected:
+  // Subclasses should override this to provide their own BrowserMainParts
+  // implementation. The lifetime of the returned instance is managed by the
+  // caller.
+  virtual BrowserMainParts* OverrideCreateBrowserMainParts(
+      const content::MainFunctionParams&);
+
+ private:
   BrowserMainParts* browser_main_parts_;
   NetLog net_log_;
 
- private:
-  scoped_ptr<PlatformNotificationService> notification_service_;
-  scoped_ptr<NotificationPresenter> notification_presenter_;
+  std::unique_ptr<PlatformNotificationService> notification_service_;
+  std::unique_ptr<NotificationPresenter> notification_presenter_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserClient);
 };
diff --git a/brightray/browser/browser_context.cc b/brightray/browser/browser_context.cc
index 12d1d3577414..236a8f5c1f21 100644
--- a/brightray/browser/browser_context.cc
+++ b/brightray/browser/browser_context.cc
@@ -5,6 +5,7 @@
 #include "browser/browser_context.h"
 
 #include "browser/brightray_paths.h"
+#include "browser/browser_client.h"
 #include "browser/inspectable_web_contents_impl.h"
 #include "browser/network_delegate.h"
 #include "browser/permission_manager.h"
@@ -64,16 +65,16 @@ class BrowserContext::ResourceContext : public content::ResourceContext {
     return getter_->GetURLRequestContext();
   }
 
-  scoped_ptr<net::ClientCertStore> CreateClientCertStore() override {
+  std::unique_ptr<net::ClientCertStore> CreateClientCertStore() override {
     #if defined(USE_NSS_CERTS)
-      return scoped_ptr<net::ClientCertStore>(new net::ClientCertStoreNSS(
+      return std::unique_ptr<net::ClientCertStore>(new net::ClientCertStoreNSS(
           net::ClientCertStoreNSS::PasswordDelegateFactory()));
     #elif defined(OS_WIN)
-      return scoped_ptr<net::ClientCertStore>(new net::ClientCertStoreWin());
+      return std::unique_ptr<net::ClientCertStore>(new net::ClientCertStoreWin());
     #elif defined(OS_MACOSX)
-      return scoped_ptr<net::ClientCertStore>(new net::ClientCertStoreMac());
+      return std::unique_ptr<net::ClientCertStore>(new net::ClientCertStoreMac());
     #elif defined(USE_OPENSSL)
-      return scoped_ptr<net::ClientCertStore>();
+      return std::unique_ptr<net::ClientCertStore>();
     #endif
   }
 
@@ -110,6 +111,8 @@ BrowserContext::BrowserContext(const std::string& partition, bool in_memory)
   if (!in_memory_ && !partition.empty())
     path_ = path_.Append(FILE_PATH_LITERAL("Partitions"))
                  .Append(base::FilePath::FromUTF8Unsafe(MakePartitionName(partition)));
+
+  content::BrowserContext::Initialize(this, path_);
 }
 
 void BrowserContext::InitPrefs() {
@@ -137,14 +140,13 @@ void BrowserContext::RegisterInternalPrefs(PrefRegistrySimple* registry) {
 }
 
 net::URLRequestContextGetter* BrowserContext::CreateRequestContext(
-    NetLog* net_log,
     content::ProtocolHandlerMap* protocol_handlers,
     content::URLRequestInterceptorScopedVector protocol_interceptors) {
   DCHECK(!url_request_getter_.get());
   url_request_getter_ = new URLRequestContextGetter(
       this,
       network_controller_handle(),
-      net_log,
+      static_cast<NetLog*>(BrowserClient::Get()->GetNetLog()),
       GetPath(),
       in_memory_,
       BrowserThread::UnsafeGetMessageLoopForThread(BrowserThread::IO),
@@ -163,9 +165,9 @@ base::FilePath BrowserContext::GetPath() const {
   return path_;
 }
 
-scoped_ptr<content::ZoomLevelDelegate> BrowserContext::CreateZoomLevelDelegate(
+std::unique_ptr<content::ZoomLevelDelegate> BrowserContext::CreateZoomLevelDelegate(
     const base::FilePath& partition_path) {
-  return scoped_ptr<content::ZoomLevelDelegate>();
+  return std::unique_ptr<content::ZoomLevelDelegate>();
 }
 
 bool BrowserContext::IsOffTheRecord() const {
@@ -176,11 +178,6 @@ net::URLRequestContextGetter* BrowserContext::GetRequestContext() {
   return GetDefaultStoragePartition(this)->GetURLRequestContext();
 }
 
-net::URLRequestContextGetter* BrowserContext::GetRequestContextForRenderProcess(
-    int renderer_child_id) {
-  return GetRequestContext();
-}
-
 net::URLRequestContextGetter* BrowserContext::GetMediaRequestContext() {
   return GetRequestContext();
 }
@@ -232,4 +229,13 @@ content::BackgroundSyncController* BrowserContext::GetBackgroundSyncController()
   return nullptr;
 }
 
+net::URLRequestContextGetter*
+BrowserContext::CreateRequestContextForStoragePartition(
+    const base::FilePath& partition_path,
+    bool in_memory,
+    content::ProtocolHandlerMap* protocol_handlers,
+    content::URLRequestInterceptorScopedVector request_interceptors) {
+  return nullptr;
+}
+
 }  // namespace brightray
diff --git a/brightray/browser/browser_context.h b/brightray/browser/browser_context.h
index 5ec2b2bcedef..31db2ce23f47 100644
--- a/brightray/browser/browser_context.h
+++ b/brightray/browser/browser_context.h
@@ -39,12 +39,10 @@ class BrowserContext : public base::RefCounted<BrowserContext>,
       const std::string& partition, bool in_memory);
 
   // content::BrowserContext:
-  scoped_ptr<content::ZoomLevelDelegate> CreateZoomLevelDelegate(
+  std::unique_ptr<content::ZoomLevelDelegate> CreateZoomLevelDelegate(
       const base::FilePath& partition_path) override;
   bool IsOffTheRecord() const override;
   net::URLRequestContextGetter* GetRequestContext() override;
-  net::URLRequestContextGetter* GetRequestContextForRenderProcess(
-      int renderer_child_id) override;
   net::URLRequestContextGetter* GetMediaRequestContext() override;
   net::URLRequestContextGetter* GetMediaRequestContextForRenderProcess(
       int renderer_child_id) override;
@@ -58,11 +56,14 @@ class BrowserContext : public base::RefCounted<BrowserContext>,
   content::SSLHostStateDelegate* GetSSLHostStateDelegate() override;
   content::PermissionManager* GetPermissionManager() override;
   content::BackgroundSyncController* GetBackgroundSyncController() override;
-
   net::URLRequestContextGetter* CreateRequestContext(
-      NetLog* net_log,
       content::ProtocolHandlerMap* protocol_handlers,
-      content::URLRequestInterceptorScopedVector protocol_interceptors);
+      content::URLRequestInterceptorScopedVector request_interceptors) override;
+  net::URLRequestContextGetter* CreateRequestContextForStoragePartition(
+      const base::FilePath& partition_path,
+      bool in_memory,
+      content::ProtocolHandlerMap* protocol_handlers,
+      content::URLRequestInterceptorScopedVector request_interceptors) override;
 
   net::URLRequestContextGetter* url_request_context_getter() const {
     return url_request_getter_.get();
@@ -120,11 +121,11 @@ class BrowserContext : public base::RefCounted<BrowserContext>,
 
   DevToolsNetworkControllerHandle network_controller_handle_;
 
-  scoped_ptr<ResourceContext> resource_context_;
+  std::unique_ptr<ResourceContext> resource_context_;
   scoped_refptr<URLRequestContextGetter> url_request_getter_;
   scoped_refptr<storage::SpecialStoragePolicy> storage_policy_;
-  scoped_ptr<PrefService> prefs_;
-  scoped_ptr<PermissionManager> permission_manager_;
+  std::unique_ptr<PrefService> prefs_;
+  std::unique_ptr<PermissionManager> permission_manager_;
 
   base::WeakPtrFactory<BrowserContext> weak_factory_;
 
diff --git a/brightray/browser/browser_main_parts.cc b/brightray/browser/browser_main_parts.cc
index 11bbe90c4977..43c49de8d441 100644
--- a/brightray/browser/browser_main_parts.cc
+++ b/brightray/browser/browser_main_parts.cc
@@ -10,6 +10,7 @@
 #include "common/main_delegate.h"
 
 #include "base/command_line.h"
+#include "base/feature_list.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/devtools_http_handler/devtools_http_handler.h"
@@ -76,7 +77,7 @@ void OverrideLinuxAppDataPath() {
   base::FilePath path;
   if (PathService::Get(DIR_APP_DATA, &path))
     return;
-  scoped_ptr<base::Environment> env(base::Environment::Create());
+  std::unique_ptr<base::Environment> env(base::Environment::Create());
   path = base::nix::GetXDGDirectory(env.get(),
                                     base::nix::kXdgConfigHomeEnvVar,
                                     base::nix::kDotConfigDir);
@@ -153,6 +154,10 @@ BrowserMainParts::~BrowserMainParts() {
 }
 
 void BrowserMainParts::PreEarlyInitialization() {
+  std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
+  feature_list->InitializeFromCommandLine("", "");
+  base::FeatureList::SetInstance(std::move(feature_list));
+
 #if defined(USE_X11)
   views::LinuxUI::SetInstance(BuildGtk2UI());
   OverrideLinuxAppDataPath();
diff --git a/brightray/browser/browser_main_parts.h b/brightray/browser/browser_main_parts.h
index 5b50516f7cc2..40adc027282d 100644
--- a/brightray/browser/browser_main_parts.h
+++ b/brightray/browser/browser_main_parts.h
@@ -7,7 +7,6 @@
 
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "content/public/browser/browser_main_parts.h"
 
 namespace devtools_http_handler {
@@ -53,14 +52,14 @@ class BrowserMainParts : public content::BrowserMainParts {
 #endif
 
   scoped_refptr<BrowserContext> browser_context_;
-  scoped_ptr<devtools_http_handler::DevToolsHttpHandler> devtools_http_handler_;
+  std::unique_ptr<devtools_http_handler::DevToolsHttpHandler> devtools_http_handler_;
 
 #if defined(TOOLKIT_VIEWS)
-  scoped_ptr<ViewsDelegate> views_delegate_;
+  std::unique_ptr<ViewsDelegate> views_delegate_;
 #endif
 
 #if defined(USE_AURA) && defined(USE_X11)
-  scoped_ptr<wm::WMState> wm_state_;
+  std::unique_ptr<wm::WMState> wm_state_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(BrowserMainParts);
diff --git a/brightray/browser/devtools_manager_delegate.cc b/brightray/browser/devtools_manager_delegate.cc
index b79c94f8140f..1464362f3ad7 100644
--- a/brightray/browser/devtools_manager_delegate.cc
+++ b/brightray/browser/devtools_manager_delegate.cc
@@ -45,11 +45,11 @@ class TCPServerSocketFactory
 
  private:
   // content::DevToolsHttpHandler::ServerSocketFactory.
-  scoped_ptr<net::ServerSocket> CreateForHttpServer() override {
-    scoped_ptr<net::ServerSocket> socket(
+  std::unique_ptr<net::ServerSocket> CreateForHttpServer() override {
+    std::unique_ptr<net::ServerSocket> socket(
         new net::TCPServerSocket(nullptr, net::NetLog::Source()));
     if (socket->ListenWithAddressAndPort(address_, port_, 10) != net::OK)
-      return scoped_ptr<net::ServerSocket>();
+      return std::unique_ptr<net::ServerSocket>();
 
     return socket;
   }
@@ -60,7 +60,7 @@ class TCPServerSocketFactory
   DISALLOW_COPY_AND_ASSIGN(TCPServerSocketFactory);
 };
 
-scoped_ptr<devtools_http_handler::DevToolsHttpHandler::ServerSocketFactory>
+std::unique_ptr<devtools_http_handler::DevToolsHttpHandler::ServerSocketFactory>
 CreateSocketFactory() {
   auto& command_line = *base::CommandLine::ForCurrentProcess();
   // See if the user specified a port on the command line (useful for
@@ -77,7 +77,7 @@ CreateSocketFactory() {
       DLOG(WARNING) << "Invalid http debugger port number " << temp_port;
     }
   }
-  return scoped_ptr<
+  return std::unique_ptr<
       devtools_http_handler::DevToolsHttpHandler::ServerSocketFactory>(
           new TCPServerSocketFactory("127.0.0.1", port));
 }
diff --git a/brightray/browser/devtools_manager_delegate.h b/brightray/browser/devtools_manager_delegate.h
index 34e6a6bd7047..23d28c74dbbf 100644
--- a/brightray/browser/devtools_manager_delegate.h
+++ b/brightray/browser/devtools_manager_delegate.h
@@ -34,7 +34,7 @@ class DevToolsManagerDelegate : public content::DevToolsManagerDelegate {
                                        base::DictionaryValue* command) override;
 
  private:
-  scoped_ptr<DevToolsNetworkProtocolHandler> handler_;
+  std::unique_ptr<DevToolsNetworkProtocolHandler> handler_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsManagerDelegate);
 };
diff --git a/brightray/browser/inspectable_web_contents_impl.cc b/brightray/browser/inspectable_web_contents_impl.cc
index be85d4a37d78..99efcd3984c8 100644
--- a/brightray/browser/inspectable_web_contents_impl.cc
+++ b/brightray/browser/inspectable_web_contents_impl.cc
@@ -190,7 +190,7 @@ InspectableWebContentsView* CreateInspectableContentsView(
     InspectableWebContentsImpl* inspectable_web_contents_impl);
 
 void InspectableWebContentsImpl::RegisterPrefs(PrefRegistrySimple* registry) {
-  auto bounds_dict = make_scoped_ptr(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> bounds_dict(new base::DictionaryValue);
   RectToDictionary(gfx::Rect(0, 0, 800, 600), bounds_dict.get());
   registry->RegisterDictionaryPref(kDevToolsBoundsPref, bounds_dict.release());
   registry->RegisterDoublePref(kDevToolsZoomPref, 0.);
@@ -412,7 +412,7 @@ void InspectableWebContentsImpl::LoadNetworkResource(
   pending_requests_[fetcher] = callback;
   fetcher->SetRequestContext(browser_context->url_request_context_getter());
   fetcher->SetExtraRequestHeaders(headers);
-  fetcher->SaveResponseWithWriter(scoped_ptr<net::URLFetcherResponseWriter>(
+  fetcher->SaveResponseWithWriter(std::unique_ptr<net::URLFetcherResponseWriter>(
       new ResponseWriter(weak_factory_.GetWeakPtr(), stream_id)));
   fetcher->Start();
 }
@@ -562,7 +562,7 @@ void InspectableWebContentsImpl::HandleMessageFromDevToolsFrontend(const std::st
   base::ListValue* params = &empty_params;
 
   base::DictionaryValue* dict = nullptr;
-  scoped_ptr<base::Value> parsed_message(base::JSONReader::Read(message));
+  std::unique_ptr<base::Value> parsed_message(base::JSONReader::Read(message));
   if (!parsed_message ||
       !parsed_message->GetAsDictionary(&dict) ||
       !dict->GetString(kFrontendHostMethod, &method) ||
diff --git a/brightray/browser/inspectable_web_contents_impl.h b/brightray/browser/inspectable_web_contents_impl.h
index b6e91a7d0f55..f9496a75398d 100644
--- a/brightray/browser/inspectable_web_contents_impl.h
+++ b/brightray/browser/inspectable_web_contents_impl.h
@@ -162,8 +162,8 @@ class InspectableWebContentsImpl :
 
   bool frontend_loaded_;
   scoped_refptr<content::DevToolsAgentHost> agent_host_;
-  scoped_ptr<content::DevToolsFrontendHost> frontend_host_;
-  scoped_ptr<DevToolsEmbedderMessageDispatcher> embedder_message_dispatcher_;
+  std::unique_ptr<content::DevToolsFrontendHost> frontend_host_;
+  std::unique_ptr<DevToolsEmbedderMessageDispatcher> embedder_message_dispatcher_;
 
   DevToolsContentsResizingStrategy contents_resizing_strategy_;
   gfx::Rect devtools_bounds_;
@@ -176,9 +176,9 @@ class InspectableWebContentsImpl :
 
   PrefService* pref_service_;  // weak reference.
 
-  scoped_ptr<content::WebContents> web_contents_;
-  scoped_ptr<content::WebContents> devtools_web_contents_;
-  scoped_ptr<InspectableWebContentsView> view_;
+  std::unique_ptr<content::WebContents> web_contents_;
+  std::unique_ptr<content::WebContents> devtools_web_contents_;
+  std::unique_ptr<InspectableWebContentsView> view_;
 
   base::WeakPtrFactory<InspectableWebContentsImpl> weak_factory_;
 
diff --git a/brightray/browser/mac/cocoa_notification.h b/brightray/browser/mac/cocoa_notification.h
index 7287f00f2456..f6ec9e9da6b0 100644
--- a/brightray/browser/mac/cocoa_notification.h
+++ b/brightray/browser/mac/cocoa_notification.h
@@ -8,7 +8,6 @@
 #import <Foundation/Foundation.h>
 
 #include "base/mac/scoped_nsobject.h"
-#include "base/memory/scoped_ptr.h"
 #include "browser/notification.h"
 
 namespace brightray {
diff --git a/brightray/browser/media/media_capture_devices_dispatcher.h b/brightray/browser/media/media_capture_devices_dispatcher.h
index c62a917572d2..27fe67664694 100644
--- a/brightray/browser/media/media_capture_devices_dispatcher.h
+++ b/brightray/browser/media/media_capture_devices_dispatcher.h
@@ -6,7 +6,6 @@
 #define BRIGHTRAY_BROWSER_MEDIA_MEDIA_CAPTURE_DEVICES_DISPATCHER_H_
 
 #include "base/callback.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "content/public/browser/media_observer.h"
 #include "content/public/browser/web_contents_delegate.h"
diff --git a/brightray/browser/media/media_stream_devices_controller.cc b/brightray/browser/media/media_stream_devices_controller.cc
index 1a205f1ed775..103feea369d1 100644
--- a/brightray/browser/media/media_stream_devices_controller.cc
+++ b/brightray/browser/media/media_stream_devices_controller.cc
@@ -43,7 +43,7 @@ MediaStreamDevicesController::~MediaStreamDevicesController() {
   if (!callback_.is_null()) {
     callback_.Run(content::MediaStreamDevices(),
                   content::MEDIA_DEVICE_INVALID_STATE,
-                  scoped_ptr<content::MediaStreamUI>());
+                  std::unique_ptr<content::MediaStreamUI>());
   }
 }
 
@@ -146,7 +146,7 @@ void MediaStreamDevicesController::Accept() {
 
   content::MediaResponseCallback cb = callback_;
   callback_.Reset();
-  cb.Run(devices, content::MEDIA_DEVICE_OK, scoped_ptr<content::MediaStreamUI>());
+  cb.Run(devices, content::MEDIA_DEVICE_OK, std::unique_ptr<content::MediaStreamUI>());
 }
 
 void MediaStreamDevicesController::Deny(content::MediaStreamRequestResult result) {
@@ -154,7 +154,7 @@ void MediaStreamDevicesController::Deny(content::MediaStreamRequestResult result
   callback_.Reset();
   cb.Run(content::MediaStreamDevices(),
          result,
-         scoped_ptr<content::MediaStreamUI>());
+         std::unique_ptr<content::MediaStreamUI>());
 }
 
 void MediaStreamDevicesController::HandleUserMediaRequest() {
@@ -194,7 +194,7 @@ void MediaStreamDevicesController::HandleUserMediaRequest() {
   cb.Run(devices,
          devices.empty() ? content::MEDIA_DEVICE_INVALID_STATE :
                            content::MEDIA_DEVICE_OK,
-         scoped_ptr<content::MediaStreamUI>());
+         std::unique_ptr<content::MediaStreamUI>());
 }
 
 }  // namespace brightray
diff --git a/brightray/browser/net/devtools_network_controller.cc b/brightray/browser/net/devtools_network_controller.cc
index 7313a3784321..cb2f92ba222b 100644
--- a/brightray/browser/net/devtools_network_controller.cc
+++ b/brightray/browser/net/devtools_network_controller.cc
@@ -24,20 +24,20 @@ DevToolsNetworkController::~DevToolsNetworkController() {
 
 void DevToolsNetworkController::SetNetworkState(
     const std::string& client_id,
-    scoped_ptr<DevToolsNetworkConditions> conditions) {
+    std::unique_ptr<DevToolsNetworkConditions> conditions) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   DevToolsNetworkInterceptor* interceptor = interceptors_.get(client_id);
   if (!interceptor) {
     if (!conditions)
       return;
-    scoped_ptr<DevToolsNetworkInterceptor> new_interceptor(
+    std::unique_ptr<DevToolsNetworkInterceptor> new_interceptor(
         new DevToolsNetworkInterceptor);
     new_interceptor->UpdateConditions(std::move(conditions));
     interceptors_.set(client_id, std::move(new_interceptor));
   } else {
     if (!conditions) {
-      scoped_ptr<DevToolsNetworkConditions> online_conditions(
+      std::unique_ptr<DevToolsNetworkConditions> online_conditions(
           new DevToolsNetworkConditions(false));
       interceptor->UpdateConditions(std::move(online_conditions));
       interceptors_.erase(client_id);
@@ -57,7 +57,7 @@ void DevToolsNetworkController::SetNetworkState(
 
   bool is_appcache_offline = appcache_interceptor_->IsOffline();
   if (is_appcache_offline != has_offline_interceptors) {
-    scoped_ptr<DevToolsNetworkConditions> appcache_conditions(
+    std::unique_ptr<DevToolsNetworkConditions> appcache_conditions(
         new DevToolsNetworkConditions(has_offline_interceptors));
     appcache_interceptor_->UpdateConditions(std::move(appcache_conditions));
   }
diff --git a/brightray/browser/net/devtools_network_controller.h b/brightray/browser/net/devtools_network_controller.h
index 2e3ab419da4f..02bb69855941 100644
--- a/brightray/browser/net/devtools_network_controller.h
+++ b/brightray/browser/net/devtools_network_controller.h
@@ -7,7 +7,6 @@
 
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 
 namespace brightray {
 
@@ -21,14 +20,14 @@ class DevToolsNetworkController {
   virtual ~DevToolsNetworkController();
 
   void SetNetworkState(const std::string& client_id,
-                       scoped_ptr<DevToolsNetworkConditions> conditions);
+                       std::unique_ptr<DevToolsNetworkConditions> conditions);
   DevToolsNetworkInterceptor* GetInterceptor(const std::string& client_id);
 
  private:
   using InterceptorMap = base::ScopedPtrHashMap<std::string,
-                                                scoped_ptr<DevToolsNetworkInterceptor>>;
+                                                std::unique_ptr<DevToolsNetworkInterceptor>>;
 
-  scoped_ptr<DevToolsNetworkInterceptor> appcache_interceptor_;
+  std::unique_ptr<DevToolsNetworkInterceptor> appcache_interceptor_;
   InterceptorMap interceptors_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkController);
diff --git a/brightray/browser/net/devtools_network_controller_handle.cc b/brightray/browser/net/devtools_network_controller_handle.cc
index efc53a23a178..44b7b9c6c14d 100644
--- a/brightray/browser/net/devtools_network_controller_handle.cc
+++ b/brightray/browser/net/devtools_network_controller_handle.cc
@@ -25,7 +25,7 @@ DevToolsNetworkControllerHandle::~DevToolsNetworkControllerHandle() {
 
 void DevToolsNetworkControllerHandle::SetNetworkState(
     const std::string& client_id,
-    scoped_ptr<DevToolsNetworkConditions> conditions) {
+    std::unique_ptr<DevToolsNetworkConditions> conditions) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BrowserThread::PostTask(
@@ -50,7 +50,7 @@ void DevToolsNetworkControllerHandle::LazyInitialize() {
 
 void DevToolsNetworkControllerHandle::SetNetworkStateOnIO(
     const std::string& client_id,
-    scoped_ptr<DevToolsNetworkConditions> conditions) {
+    std::unique_ptr<DevToolsNetworkConditions> conditions) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   LazyInitialize();
diff --git a/brightray/browser/net/devtools_network_controller_handle.h b/brightray/browser/net/devtools_network_controller_handle.h
index f009d2732683..b5c861f5cd6c 100644
--- a/brightray/browser/net/devtools_network_controller_handle.h
+++ b/brightray/browser/net/devtools_network_controller_handle.h
@@ -5,10 +5,10 @@
 #ifndef BROWSER_DEVTOOLS_NETWORK_CONTROLLER_HANDLE_H_
 #define BROWSER_DEVTOOLS_NETWORK_CONTROLLER_HANDLE_H_
 
+#include <memory>
 #include <string>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 
 namespace brightray {
 
@@ -24,7 +24,7 @@ class DevToolsNetworkControllerHandle {
 
   // Called on the UI thread.
   void SetNetworkState(const std::string& client_id,
-                       scoped_ptr<DevToolsNetworkConditions> conditions);
+                       std::unique_ptr<DevToolsNetworkConditions> conditions);
 
   // Called on the IO thread.
   DevToolsNetworkController* GetController();
@@ -32,9 +32,9 @@ class DevToolsNetworkControllerHandle {
  private:
   void LazyInitialize();
   void SetNetworkStateOnIO(const std::string& client_id,
-                           scoped_ptr<DevToolsNetworkConditions> conditions);
+                           std::unique_ptr<DevToolsNetworkConditions> conditions);
 
-  scoped_ptr<DevToolsNetworkController> controller_;
+  std::unique_ptr<DevToolsNetworkController> controller_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkControllerHandle);
 };
diff --git a/brightray/browser/net/devtools_network_interceptor.cc b/brightray/browser/net/devtools_network_interceptor.cc
index f1f8c63ae556..fa866b4aa123 100644
--- a/brightray/browser/net/devtools_network_interceptor.cc
+++ b/brightray/browser/net/devtools_network_interceptor.cc
@@ -66,7 +66,7 @@ void DevToolsNetworkInterceptor::FinishRecords(
 }
 
 void DevToolsNetworkInterceptor::UpdateConditions(
-    scoped_ptr<DevToolsNetworkConditions> conditions) {
+    std::unique_ptr<DevToolsNetworkConditions> conditions) {
   DCHECK(conditions);
   base::TimeTicks now = base::TimeTicks::Now();
   if (conditions_->IsThrottling())
diff --git a/brightray/browser/net/devtools_network_interceptor.h b/brightray/browser/net/devtools_network_interceptor.h
index d1293e41acc8..4a04876b6f17 100644
--- a/brightray/browser/net/devtools_network_interceptor.h
+++ b/brightray/browser/net/devtools_network_interceptor.h
@@ -10,7 +10,6 @@
 #include <vector>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/timer/timer.h"
 
 namespace base {
@@ -33,7 +32,7 @@ class DevToolsNetworkInterceptor {
   base::WeakPtr<DevToolsNetworkInterceptor> GetWeakPtr();
 
   // Applies network emulation configuration.
-  void UpdateConditions(scoped_ptr<DevToolsNetworkConditions> conditions);
+  void UpdateConditions(std::unique_ptr<DevToolsNetworkConditions> conditions);
 
   // Throttles with |is_upload == true| always succeed, even in offline mode.
   int StartThrottle(int result,
@@ -81,7 +80,7 @@ class DevToolsNetworkInterceptor {
 
   void RemoveRecord(ThrottleRecords* records, const ThrottleCallback& callback);
 
-  scoped_ptr<DevToolsNetworkConditions> conditions_;
+  std::unique_ptr<DevToolsNetworkConditions> conditions_;
 
   // Throttables suspended for a "latency" period.
   ThrottleRecords suspended_;
diff --git a/brightray/browser/net/devtools_network_protocol_handler.cc b/brightray/browser/net/devtools_network_protocol_handler.cc
index b5e723d06a6b..60a3a15a0a39 100644
--- a/brightray/browser/net/devtools_network_protocol_handler.cc
+++ b/brightray/browser/net/devtools_network_protocol_handler.cc
@@ -59,17 +59,17 @@ bool ParseCommand(const base::DictionaryValue* command,
   return true;
 }
 
-scoped_ptr<base::DictionaryValue>
-CreateSuccessResponse(int id, scoped_ptr<base::DictionaryValue> result) {
-  scoped_ptr<base::DictionaryValue> response(new base::DictionaryValue);
+std::unique_ptr<base::DictionaryValue>
+CreateSuccessResponse(int id, std::unique_ptr<base::DictionaryValue> result) {
+  std::unique_ptr<base::DictionaryValue> response(new base::DictionaryValue);
   response->SetInteger(kId, id);
   response->Set(params::kResult, result.release());
   return response;
 }
 
-scoped_ptr<base::DictionaryValue>
+std::unique_ptr<base::DictionaryValue>
 CreateFailureResponse(int id, const std::string& param) {
-  scoped_ptr<base::DictionaryValue> response(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> response(new base::DictionaryValue);
   auto error_object = new base::DictionaryValue;
   response->Set(kError, error_object);
   error_object->SetInteger(params::kErrorCode, kErrorInvalidParams);
@@ -108,23 +108,23 @@ base::DictionaryValue* DevToolsNetworkProtocolHandler::HandleCommand(
 void DevToolsNetworkProtocolHandler::DevToolsAgentStateChanged(
     content::DevToolsAgentHost* agent_host,
     bool attached) {
-  scoped_ptr<DevToolsNetworkConditions> conditions;
+  std::unique_ptr<DevToolsNetworkConditions> conditions;
   if (attached)
     conditions.reset(new DevToolsNetworkConditions(false));
   UpdateNetworkState(agent_host, std::move(conditions));
 }
 
-scoped_ptr<base::DictionaryValue>
+std::unique_ptr<base::DictionaryValue>
 DevToolsNetworkProtocolHandler::CanEmulateNetworkConditions(
     content::DevToolsAgentHost* agent_host,
     int id,
     const base::DictionaryValue* params) {
-  scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue);
   result->SetBoolean(params::kResult, true);
   return CreateSuccessResponse(id, std::move(result));
 }
 
-scoped_ptr<base::DictionaryValue>
+std::unique_ptr<base::DictionaryValue>
 DevToolsNetworkProtocolHandler::EmulateNetworkConditions(
     content::DevToolsAgentHost* agent_host,
     int id,
@@ -151,18 +151,18 @@ DevToolsNetworkProtocolHandler::EmulateNetworkConditions(
   if (upload_throughput < 0.0)
     upload_throughput = 0.0;
 
-  scoped_ptr<DevToolsNetworkConditions> conditions(
+  std::unique_ptr<DevToolsNetworkConditions> conditions(
       new DevToolsNetworkConditions(offline,
                                     latency,
                                     download_throughput,
                                     upload_throughput));
   UpdateNetworkState(agent_host, std::move(conditions));
-  return scoped_ptr<base::DictionaryValue>();
+  return std::unique_ptr<base::DictionaryValue>();
 }
 
 void DevToolsNetworkProtocolHandler::UpdateNetworkState(
     content::DevToolsAgentHost* agent_host,
-    scoped_ptr<DevToolsNetworkConditions> conditions) {
+    std::unique_ptr<DevToolsNetworkConditions> conditions) {
   auto browser_context =
       static_cast<brightray::BrowserContext*>(agent_host->GetBrowserContext());
   browser_context->network_controller_handle()->SetNetworkState(
diff --git a/brightray/browser/net/devtools_network_protocol_handler.h b/brightray/browser/net/devtools_network_protocol_handler.h
index fd9c996cdc1c..9ec577814c37 100644
--- a/brightray/browser/net/devtools_network_protocol_handler.h
+++ b/brightray/browser/net/devtools_network_protocol_handler.h
@@ -6,7 +6,6 @@
 #define BROWSER_DEVTOOLS_NETWORK_PROTOCOL_HANDLER_H_
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 
 namespace content {
@@ -29,17 +28,17 @@ class DevToolsNetworkProtocolHandler {
                                  bool attached);
 
  private:
-  scoped_ptr<base::DictionaryValue> CanEmulateNetworkConditions(
+  std::unique_ptr<base::DictionaryValue> CanEmulateNetworkConditions(
       content::DevToolsAgentHost* agent_host,
       int command_id,
       const base::DictionaryValue* params);
-  scoped_ptr<base::DictionaryValue> EmulateNetworkConditions(
+  std::unique_ptr<base::DictionaryValue> EmulateNetworkConditions(
       content::DevToolsAgentHost* agent_host,
       int command_id,
       const base::DictionaryValue* params);
   void UpdateNetworkState(
       content::DevToolsAgentHost* agent_host,
-      scoped_ptr<DevToolsNetworkConditions> conditions);
+      std::unique_ptr<DevToolsNetworkConditions> conditions);
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkProtocolHandler);
 };
diff --git a/brightray/browser/net/devtools_network_transaction.cc b/brightray/browser/net/devtools_network_transaction.cc
index 48ed4232db80..e4c057b289df 100644
--- a/brightray/browser/net/devtools_network_transaction.cc
+++ b/brightray/browser/net/devtools_network_transaction.cc
@@ -22,7 +22,7 @@ const char
 
 DevToolsNetworkTransaction::DevToolsNetworkTransaction(
     DevToolsNetworkController* controller,
-    scoped_ptr<net::HttpTransaction> transaction)
+    std::unique_ptr<net::HttpTransaction> transaction)
     : throttled_byte_count_(0),
       controller_(controller),
       transaction_(std::move(transaction)),
diff --git a/brightray/browser/net/devtools_network_transaction.h b/brightray/browser/net/devtools_network_transaction.h
index a7f08651f656..3de3a1587676 100644
--- a/brightray/browser/net/devtools_network_transaction.h
+++ b/brightray/browser/net/devtools_network_transaction.h
@@ -7,7 +7,6 @@
 
 #include <stdint.h>
 
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "browser/net/devtools_network_interceptor.h"
 #include "net/base/completion_callback.h"
@@ -27,7 +26,7 @@ class DevToolsNetworkTransaction : public net::HttpTransaction {
 
   DevToolsNetworkTransaction(
       DevToolsNetworkController* controller,
-      scoped_ptr<net::HttpTransaction> network_transaction);
+      std::unique_ptr<net::HttpTransaction> network_transaction);
   ~DevToolsNetworkTransaction() override;
 
   // HttpTransaction methods:
@@ -89,13 +88,13 @@ class DevToolsNetworkTransaction : public net::HttpTransaction {
   base::WeakPtr<DevToolsNetworkInterceptor> interceptor_;
 
   // Modified upload data stream. Should be destructed after |custom_request_|.
-  scoped_ptr<DevToolsNetworkUploadDataStream> custom_upload_data_stream_;
+  std::unique_ptr<DevToolsNetworkUploadDataStream> custom_upload_data_stream_;
 
   // Modified request. Should be destructed after |transaction_|.
-  scoped_ptr<net::HttpRequestInfo> custom_request_;
+  std::unique_ptr<net::HttpRequestInfo> custom_request_;
 
   // Original network transaction.
-  scoped_ptr<net::HttpTransaction> transaction_;
+  std::unique_ptr<net::HttpTransaction> transaction_;
 
   const net::HttpRequestInfo* request_;
 
diff --git a/brightray/browser/net/devtools_network_transaction_factory.cc b/brightray/browser/net/devtools_network_transaction_factory.cc
index d3fb4cfb08b5..7373c14ddeff 100644
--- a/brightray/browser/net/devtools_network_transaction_factory.cc
+++ b/brightray/browser/net/devtools_network_transaction_factory.cc
@@ -30,8 +30,8 @@ DevToolsNetworkTransactionFactory::~DevToolsNetworkTransactionFactory() {
 
 int DevToolsNetworkTransactionFactory::CreateTransaction(
     net::RequestPriority priority,
-    scoped_ptr<net::HttpTransaction>* transaction) {
-  scoped_ptr<net::HttpTransaction> new_transaction;
+    std::unique_ptr<net::HttpTransaction>* transaction) {
+  std::unique_ptr<net::HttpTransaction> new_transaction;
   int rv = network_layer_->CreateTransaction(priority, &new_transaction);
   if (rv != net::OK)
     return rv;
diff --git a/brightray/browser/net/devtools_network_transaction_factory.h b/brightray/browser/net/devtools_network_transaction_factory.h
index a14d97c1d131..a6c8f6a3c2dd 100644
--- a/brightray/browser/net/devtools_network_transaction_factory.h
+++ b/brightray/browser/net/devtools_network_transaction_factory.h
@@ -6,7 +6,6 @@
 #define BROWSER_DEVTOOLS_NETWORK_TRANSACTION_FACTORY_H_
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_transaction_factory.h"
 
@@ -23,13 +22,13 @@ class DevToolsNetworkTransactionFactory : public net::HttpTransactionFactory {
 
   // net::HttpTransactionFactory:
   int CreateTransaction(net::RequestPriority priority,
-                        scoped_ptr<net::HttpTransaction>* transaction) override;
+                        std::unique_ptr<net::HttpTransaction>* transaction) override;
   net::HttpCache* GetCache() override;
   net::HttpNetworkSession* GetSession() override;
 
  private:
   DevToolsNetworkController*  controller_;
-  scoped_ptr<net::HttpTransactionFactory> network_layer_;
+  std::unique_ptr<net::HttpTransactionFactory> network_layer_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsNetworkTransactionFactory);
 };
diff --git a/brightray/browser/net_log.cc b/brightray/browser/net_log.cc
index b0b06483f9b7..9876b49418b3 100644
--- a/brightray/browser/net_log.cc
+++ b/brightray/browser/net_log.cc
@@ -14,8 +14,8 @@ namespace brightray {
 
 namespace {
 
-scoped_ptr<base::DictionaryValue> GetConstants() {
-  scoped_ptr<base::DictionaryValue> constants = net::GetNetConstants();
+std::unique_ptr<base::DictionaryValue> GetConstants() {
+  std::unique_ptr<base::DictionaryValue> constants = net::GetNetConstants();
 
   // Adding client information to constants dictionary.
   base::DictionaryValue* client_info = new base::DictionaryValue();
@@ -53,7 +53,7 @@ void NetLog::StartLogging(net::URLRequestContext* url_request_context) {
     return;
   }
 
-  scoped_ptr<base::Value> constants(GetConstants());
+  std::unique_ptr<base::Value> constants(GetConstants());
   write_to_file_observer_.StartObserving(this,
                                          std::move(log_file_),
                                          constants.get(),
diff --git a/brightray/browser/notification_delegate_adapter.cc b/brightray/browser/notification_delegate_adapter.cc
index 1a4853723b51..c0ad3d03f066 100644
--- a/brightray/browser/notification_delegate_adapter.cc
+++ b/brightray/browser/notification_delegate_adapter.cc
@@ -7,7 +7,7 @@
 namespace brightray {
 
 NotificationDelegateAdapter::NotificationDelegateAdapter(
-    scoped_ptr<content::DesktopNotificationDelegate> delegate)
+    std::unique_ptr<content::DesktopNotificationDelegate> delegate)
     : delegate_(std::move(delegate)) {
 }
 
diff --git a/brightray/browser/notification_delegate_adapter.h b/brightray/browser/notification_delegate_adapter.h
index b48c7376cb00..01f3284e2b85 100644
--- a/brightray/browser/notification_delegate_adapter.h
+++ b/brightray/browser/notification_delegate_adapter.h
@@ -5,7 +5,9 @@
 #ifndef BROWSER_NOTIFICATION_DELEGATE_ADAPTER_H_
 #define BROWSER_NOTIFICATION_DELEGATE_ADAPTER_H_
 
-#include "base/memory/scoped_ptr.h"
+#include <memory>
+
+#include "base/macros.h"
 #include "browser/notification_delegate.h"
 
 namespace brightray {
@@ -14,7 +16,7 @@ namespace brightray {
 class NotificationDelegateAdapter : public NotificationDelegate {
  public:
   explicit NotificationDelegateAdapter(
-      scoped_ptr<content::DesktopNotificationDelegate> delegate);
+      std::unique_ptr<content::DesktopNotificationDelegate> delegate);
   ~NotificationDelegateAdapter() override;
 
   // NotificationDelegate:
@@ -26,7 +28,7 @@ class NotificationDelegateAdapter : public NotificationDelegate {
   void NotificationClick() override;
 
  private:
-  scoped_ptr<content::DesktopNotificationDelegate> delegate_;
+  std::unique_ptr<content::DesktopNotificationDelegate> delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(NotificationDelegateAdapter);
 };
diff --git a/brightray/browser/permission_manager.cc b/brightray/browser/permission_manager.cc
index 8936678a4f7e..5431035561a5 100644
--- a/brightray/browser/permission_manager.cc
+++ b/brightray/browser/permission_manager.cc
@@ -22,12 +22,12 @@ int PermissionManager::RequestPermission(
     content::PermissionType permission,
     content::RenderFrameHost* render_frame_host,
     const GURL& requesting_origin,
-    const base::Callback<void(content::PermissionStatus)>& callback) {
+    const base::Callback<void(blink::mojom::PermissionStatus)>& callback) {
   if (permission == content::PermissionType::MIDI_SYSEX) {
     content::ChildProcessSecurityPolicy::GetInstance()->
         GrantSendMidiSysExMessage(render_frame_host->GetProcess()->GetID());
   }
-  callback.Run(content::PermissionStatus::GRANTED);
+  callback.Run(blink::mojom::PermissionStatus::GRANTED);
   return kNoPendingOperation;
 }
 
@@ -36,8 +36,8 @@ int PermissionManager::RequestPermissions(
     content::RenderFrameHost* render_frame_host,
     const GURL& requesting_origin,
     const base::Callback<void(
-        const std::vector<content::PermissionStatus>&)>& callback) {
-  std::vector<content::PermissionStatus> permissionStatuses;
+        const std::vector<blink::mojom::PermissionStatus>&)>& callback) {
+  std::vector<blink::mojom::PermissionStatus> permissionStatuses;
 
   for (auto permission : permissions) {
     if (permission == content::PermissionType::MIDI_SYSEX) {
@@ -45,7 +45,7 @@ int PermissionManager::RequestPermissions(
           GrantSendMidiSysExMessage(render_frame_host->GetProcess()->GetID());
     }
 
-    permissionStatuses.push_back(content::PermissionStatus::GRANTED);
+    permissionStatuses.push_back(blink::mojom::PermissionStatus::GRANTED);
   }
 
   callback.Run(permissionStatuses);
@@ -61,11 +61,11 @@ void PermissionManager::ResetPermission(
     const GURL& embedding_origin) {
 }
 
-content::PermissionStatus PermissionManager::GetPermissionStatus(
+blink::mojom::PermissionStatus PermissionManager::GetPermissionStatus(
     content::PermissionType permission,
     const GURL& requesting_origin,
     const GURL& embedding_origin) {
-  return content::PermissionStatus::GRANTED;
+  return blink::mojom::PermissionStatus::GRANTED;
 }
 
 void PermissionManager::RegisterPermissionUsage(
@@ -78,7 +78,7 @@ int PermissionManager::SubscribePermissionStatusChange(
     content::PermissionType permission,
     const GURL& requesting_origin,
     const GURL& embedding_origin,
-    const base::Callback<void(content::PermissionStatus)>& callback) {
+    const base::Callback<void(blink::mojom::PermissionStatus)>& callback) {
   return -1;
 }
 
diff --git a/brightray/browser/permission_manager.h b/brightray/browser/permission_manager.h
index d53fe763ce5e..3f6001c18bf4 100644
--- a/brightray/browser/permission_manager.h
+++ b/brightray/browser/permission_manager.h
@@ -21,18 +21,18 @@ class PermissionManager : public content::PermissionManager {
       content::PermissionType permission,
       content::RenderFrameHost* render_frame_host,
       const GURL& requesting_origin,
-      const base::Callback<void(content::PermissionStatus)>& callback) override;
+      const base::Callback<void(blink::mojom::PermissionStatus)>& callback) override;
   int RequestPermissions(
       const std::vector<content::PermissionType>& permissions,
       content::RenderFrameHost* render_frame_host,
       const GURL& requesting_origin,
       const base::Callback<void(
-          const std::vector<content::PermissionStatus>&)>& callback) override;
+          const std::vector<blink::mojom::PermissionStatus>&)>& callback) override;
   void CancelPermissionRequest(int request_id) override;
   void ResetPermission(content::PermissionType permission,
                        const GURL& requesting_origin,
                        const GURL& embedding_origin) override;
-  content::PermissionStatus GetPermissionStatus(
+  blink::mojom::PermissionStatus GetPermissionStatus(
       content::PermissionType permission,
       const GURL& requesting_origin,
       const GURL& embedding_origin) override;
@@ -43,7 +43,7 @@ class PermissionManager : public content::PermissionManager {
       content::PermissionType permission,
       const GURL& requesting_origin,
       const GURL& embedding_origin,
-      const base::Callback<void(content::PermissionStatus)>& callback) override;
+      const base::Callback<void(blink::mojom::PermissionStatus)>& callback) override;
   void UnsubscribePermissionStatusChange(int subscription_id) override;
 
  private:
diff --git a/brightray/browser/platform_notification_service.cc b/brightray/browser/platform_notification_service.cc
index ce539cad8d41..023f0a2a131c 100644
--- a/brightray/browser/platform_notification_service.cc
+++ b/brightray/browser/platform_notification_service.cc
@@ -25,7 +25,7 @@ void OnWebNotificationAllowed(
     brightray::BrowserClient* browser_client,
     const SkBitmap& icon,
     const content::PlatformNotificationData& data,
-    scoped_ptr<content::DesktopNotificationDelegate> delegate,
+    std::unique_ptr<content::DesktopNotificationDelegate> delegate,
     base::Closure* cancel_callback,
     bool allowed) {
   if (!allowed)
@@ -33,7 +33,7 @@ void OnWebNotificationAllowed(
   auto presenter = browser_client->GetNotificationPresenter();
   if (!presenter)
     return;
-  scoped_ptr<NotificationDelegateAdapter> adapter(
+  std::unique_ptr<NotificationDelegateAdapter> adapter(
       new NotificationDelegateAdapter(std::move(delegate)));
   auto notification = presenter->CreateNotification(adapter.get());
   if (notification) {
@@ -73,7 +73,7 @@ void PlatformNotificationService::DisplayNotification(
     const GURL& origin,
     const content::PlatformNotificationData& notification_data,
     const content::NotificationResources& notification_resources,
-    scoped_ptr<content::DesktopNotificationDelegate> delegate,
+    std::unique_ptr<content::DesktopNotificationDelegate> delegate,
     base::Closure* cancel_callback) {
   browser_client_->WebNotificationAllowed(
       render_process_id_,
diff --git a/brightray/browser/platform_notification_service.h b/brightray/browser/platform_notification_service.h
index 2f7663d588f5..1c4b53da94a6 100644
--- a/brightray/browser/platform_notification_service.h
+++ b/brightray/browser/platform_notification_service.h
@@ -5,6 +5,7 @@
 #ifndef BROWSER_PLATFORM_NOTIFICATION_SERVICE_H_
 #define BROWSER_PLATFORM_NOTIFICATION_SERVICE_H_
 
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/platform_notification_service.h"
 
 namespace brightray {
@@ -31,7 +32,7 @@ class PlatformNotificationService
       const GURL& origin,
       const content::PlatformNotificationData& notification_data,
       const content::NotificationResources& notification_resources,
-      scoped_ptr<content::DesktopNotificationDelegate> delegate,
+      std::unique_ptr<content::DesktopNotificationDelegate> delegate,
       base::Closure* cancel_callback) override;
   void DisplayPersistentNotification(
       content::BrowserContext* browser_context,
diff --git a/brightray/browser/url_request_context_getter.cc b/brightray/browser/url_request_context_getter.cc
index 7bd479e34f67..e9ba78ff0807 100644
--- a/brightray/browser/url_request_context_getter.cc
+++ b/brightray/browser/url_request_context_getter.cc
@@ -12,6 +12,7 @@
 #include "browser/network_delegate.h"
 
 #include "base/command_line.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/worker_pool.h"
@@ -104,31 +105,31 @@ std::string URLRequestContextGetter::Delegate::GetUserAgent() {
   return base::EmptyString();
 }
 
-scoped_ptr<net::URLRequestJobFactory>
+std::unique_ptr<net::URLRequestJobFactory>
 URLRequestContextGetter::Delegate::CreateURLRequestJobFactory(
     content::ProtocolHandlerMap* protocol_handlers,
     content::URLRequestInterceptorScopedVector* protocol_interceptors) {
-  scoped_ptr<net::URLRequestJobFactoryImpl> job_factory(new net::URLRequestJobFactoryImpl);
+  std::unique_ptr<net::URLRequestJobFactoryImpl> job_factory(new net::URLRequestJobFactoryImpl);
 
   for (auto it = protocol_handlers->begin(); it != protocol_handlers->end(); ++it)
     job_factory->SetProtocolHandler(
-        it->first, make_scoped_ptr(it->second.release()));
+        it->first, base::WrapUnique(it->second.release()));
   protocol_handlers->clear();
 
   job_factory->SetProtocolHandler(
-      url::kDataScheme, make_scoped_ptr(new net::DataProtocolHandler));
+      url::kDataScheme, base::WrapUnique(new net::DataProtocolHandler));
   job_factory->SetProtocolHandler(
       url::kFileScheme,
-      make_scoped_ptr(new net::FileProtocolHandler(
+      base::WrapUnique(new net::FileProtocolHandler(
           BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
               base::SequencedWorkerPool::SKIP_ON_SHUTDOWN))));
 
   // Set up interceptors in the reverse order.
-  scoped_ptr<net::URLRequestJobFactory> top_job_factory = std::move(job_factory);
+  std::unique_ptr<net::URLRequestJobFactory> top_job_factory = std::move(job_factory);
   content::URLRequestInterceptorScopedVector::reverse_iterator i;
   for (i = protocol_interceptors->rbegin(); i != protocol_interceptors->rend(); ++i)
     top_job_factory.reset(new net::URLRequestInterceptingJobFactory(
-        std::move(top_job_factory), make_scoped_ptr(*i)));
+        std::move(top_job_factory), base::WrapUnique(*i)));
   protocol_interceptors->weak_clear();
 
   return top_job_factory;
@@ -145,7 +146,7 @@ URLRequestContextGetter::Delegate::CreateHttpCacheBackendFactory(const base::Fil
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
 }
 
-scoped_ptr<net::CertVerifier>
+std::unique_ptr<net::CertVerifier>
 URLRequestContextGetter::Delegate::CreateCertVerifier() {
   return net::CertVerifier::CreateDefault();
 }
@@ -217,7 +218,7 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
 
     storage_.reset(new net::URLRequestContextStorage(url_request_context_.get()));
 
-    scoped_refptr<net::CookieStore> cookie_store = nullptr;
+    std::unique_ptr<net::CookieStore> cookie_store = nullptr;
     if (in_memory_) {
       cookie_store = content::CreateCookieStore(content::CookieStoreConfig());
     } else {
@@ -227,22 +228,22 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
           NULL, NULL);
       cookie_store = content::CreateCookieStore(cookie_config);
     }
-    storage_->set_cookie_store(cookie_store.get());
-    storage_->set_channel_id_service(make_scoped_ptr(
+    storage_->set_cookie_store(std::move(cookie_store));
+    storage_->set_channel_id_service(base::WrapUnique(
         new net::ChannelIDService(new net::DefaultChannelIDStore(NULL),
                                   base::WorkerPool::GetTaskRunner(true))));
 
     std::string accept_lang = l10n_util::GetApplicationLocale("");
-    storage_->set_http_user_agent_settings(make_scoped_ptr(
+    storage_->set_http_user_agent_settings(base::WrapUnique(
         new net::StaticHttpUserAgentSettings(
             net::HttpUtil::GenerateAcceptLanguageHeader(accept_lang),
             delegate_->GetUserAgent())));
 
-    scoped_ptr<net::HostResolver> host_resolver(net::HostResolver::CreateDefaultResolver(nullptr));
+    std::unique_ptr<net::HostResolver> host_resolver(net::HostResolver::CreateDefaultResolver(nullptr));
 
     // --host-resolver-rules
     if (command_line.HasSwitch(switches::kHostResolverRules)) {
-      scoped_ptr<net::MappedHostResolver> remapped_resolver(
+      std::unique_ptr<net::MappedHostResolver> remapped_resolver(
           new net::MappedHostResolver(std::move(host_resolver)));
       remapped_resolver->SetRulesFromString(
           command_line.GetSwitchValueASCII(switches::kHostResolverRules));
@@ -307,10 +308,10 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
 
     storage_->set_cert_verifier(delegate_->CreateCertVerifier());
     storage_->set_transport_security_state(
-        make_scoped_ptr(new net::TransportSecurityState));
+        base::WrapUnique(new net::TransportSecurityState));
     storage_->set_ssl_config_service(delegate_->CreateSSLConfigService());
     storage_->set_http_auth_handler_factory(std::move(auth_handler_factory));
-    scoped_ptr<net::HttpServerProperties> server_properties(
+    std::unique_ptr<net::HttpServerProperties> server_properties(
         new net::HttpServerPropertiesImpl);
     storage_->set_http_server_properties(std::move(server_properties));
 
@@ -318,7 +319,6 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
     network_session_params.cert_verifier = url_request_context_->cert_verifier();
     network_session_params.proxy_service = url_request_context_->proxy_service();
     network_session_params.ssl_config_service = url_request_context_->ssl_config_service();
-    network_session_params.network_delegate = url_request_context_->network_delegate();
     network_session_params.http_server_properties = url_request_context_->http_server_properties();
     network_session_params.ignore_certificate_errors = false;
     network_session_params.transport_security_state =
@@ -352,7 +352,7 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
 
     http_network_session_.reset(
         new net::HttpNetworkSession(network_session_params));
-    scoped_ptr<net::HttpCache::BackendFactory> backend;
+    std::unique_ptr<net::HttpCache::BackendFactory> backend;
     if (in_memory_) {
       backend = net::HttpCache::DefaultBackend::InMemory(0);
     } else {
@@ -360,14 +360,14 @@ net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
     }
 
     if (network_controller_handle_) {
-      storage_->set_http_transaction_factory(make_scoped_ptr(
+      storage_->set_http_transaction_factory(base::WrapUnique(
           new net::HttpCache(
-              make_scoped_ptr(new DevToolsNetworkTransactionFactory(
+              base::WrapUnique(new DevToolsNetworkTransactionFactory(
                   network_controller_handle_->GetController(), http_network_session_.get())),
               std::move(backend),
               false)));
     } else {
-      storage_->set_http_transaction_factory(make_scoped_ptr(
+      storage_->set_http_transaction_factory(base::WrapUnique(
           new net::HttpCache(http_network_session_.get(),
                              std::move(backend),
                              false)));
diff --git a/brightray/browser/url_request_context_getter.h b/brightray/browser/url_request_context_getter.h
index 546cda9b8acd..30ec8a3f3e41 100644
--- a/brightray/browser/url_request_context_getter.h
+++ b/brightray/browser/url_request_context_getter.h
@@ -6,7 +6,7 @@
 #define BRIGHTRAY_BROWSER_URL_REQUEST_CONTEXT_GETTER_H_
 
 #include "base/files/file_path.h"
-#include "base/memory/scoped_ptr.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/content_browser_client.h"
 #include "net/http/http_cache.h"
 #include "net/http/url_security_manager.h"
@@ -40,12 +40,12 @@ class URLRequestContextGetter : public net::URLRequestContextGetter {
 
     virtual net::NetworkDelegate* CreateNetworkDelegate() { return NULL; }
     virtual std::string GetUserAgent();
-    virtual scoped_ptr<net::URLRequestJobFactory> CreateURLRequestJobFactory(
+    virtual std::unique_ptr<net::URLRequestJobFactory> CreateURLRequestJobFactory(
         content::ProtocolHandlerMap* protocol_handlers,
         content::URLRequestInterceptorScopedVector* protocol_interceptors);
     virtual net::HttpCache::BackendFactory* CreateHttpCacheBackendFactory(
         const base::FilePath& base_path);
-    virtual scoped_ptr<net::CertVerifier> CreateCertVerifier();
+    virtual std::unique_ptr<net::CertVerifier> CreateCertVerifier();
     virtual net::SSLConfigService* CreateSSLConfigService();
   };
 
@@ -77,13 +77,13 @@ class URLRequestContextGetter : public net::URLRequestContextGetter {
   base::MessageLoop* io_loop_;
   base::MessageLoop* file_loop_;
 
-  scoped_ptr<net::ProxyConfigService> proxy_config_service_;
-  scoped_ptr<net::NetworkDelegate> network_delegate_;
-  scoped_ptr<net::URLRequestContextStorage> storage_;
-  scoped_ptr<net::URLRequestContext> url_request_context_;
-  scoped_ptr<net::HostMappingRules> host_mapping_rules_;
-  scoped_ptr<net::HttpAuthPreferences> http_auth_preferences_;
-  scoped_ptr<net::HttpNetworkSession> http_network_session_;
+  std::unique_ptr<net::ProxyConfigService> proxy_config_service_;
+  std::unique_ptr<net::NetworkDelegate> network_delegate_;
+  std::unique_ptr<net::URLRequestContextStorage> storage_;
+  std::unique_ptr<net::URLRequestContext> url_request_context_;
+  std::unique_ptr<net::HostMappingRules> host_mapping_rules_;
+  std::unique_ptr<net::HttpAuthPreferences> http_auth_preferences_;
+  std::unique_ptr<net::HttpNetworkSession> http_network_session_;
   content::ProtocolHandlerMap protocol_handlers_;
   content::URLRequestInterceptorScopedVector protocol_interceptors_;
 
diff --git a/brightray/browser/views/inspectable_web_contents_view_views.h b/brightray/browser/views/inspectable_web_contents_view_views.h
index bcdbdb9518bb..e73ea187ff72 100644
--- a/brightray/browser/views/inspectable_web_contents_view_views.h
+++ b/brightray/browser/views/inspectable_web_contents_view_views.h
@@ -54,7 +54,7 @@ class InspectableWebContentsViewViews : public InspectableWebContentsView,
   // Owns us.
   InspectableWebContentsImpl* inspectable_web_contents_;
 
-  scoped_ptr<views::Widget> devtools_window_;
+  std::unique_ptr<views::Widget> devtools_window_;
   views::WebView* devtools_window_web_view_;
   views::WebView* contents_web_view_;
   views::WebView* devtools_web_view_;
diff --git a/brightray/browser/win/notification_presenter_win.cc b/brightray/browser/win/notification_presenter_win.cc
index d3d4f7dc2432..107b62ea76b6 100644
--- a/brightray/browser/win/notification_presenter_win.cc
+++ b/brightray/browser/win/notification_presenter_win.cc
@@ -37,7 +37,7 @@ bool SaveIconToPath(const SkBitmap& bitmap, const base::FilePath& path) {
 NotificationPresenter* NotificationPresenter::Create() {
   if (!WindowsToastNotification::Initialize())
     return nullptr;
-  scoped_ptr<NotificationPresenterWin> presenter(new NotificationPresenterWin);
+  std::unique_ptr<NotificationPresenterWin> presenter(new NotificationPresenterWin);
   if (!presenter->Init())
     return nullptr;
   return presenter.release();
diff --git a/brightray/common/application_info_win.cc b/brightray/common/application_info_win.cc
index fd18d54b0ca4..22635711cb48 100644
--- a/brightray/common/application_info_win.cc
+++ b/brightray/common/application_info_win.cc
@@ -1,21 +1,22 @@
+#include <memory>
+
 #include "common/application_info.h"
 
 #include "base/file_version_info.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 
 namespace brightray {
 
 std::string GetApplicationName() {
   auto module = GetModuleHandle(nullptr);
-  auto info = make_scoped_ptr(
+  std::unique_ptr<FileVersionInfo> info(
       FileVersionInfo::CreateFileVersionInfoForModule(module));
   return base::UTF16ToUTF8(info->product_name());
 }
 
 std::string GetApplicationVersion() {
   auto module = GetModuleHandle(nullptr);
-  auto info = make_scoped_ptr(
+  std::unique_ptr<FileVersionInfo> info(
       FileVersionInfo::CreateFileVersionInfoForModule(module));
   return base::UTF16ToUTF8(info->product_version());
 }
diff --git a/brightray/common/main_delegate.cc b/brightray/common/main_delegate.cc
index 6516111aedd0..7dd1d153f5d5 100644
--- a/brightray/common/main_delegate.cc
+++ b/brightray/common/main_delegate.cc
@@ -4,6 +4,8 @@
 
 #include "common/main_delegate.h"
 
+#include <memory>
+
 #include "browser/browser_client.h"
 #include "common/content_client.h"
 
@@ -21,11 +23,6 @@ namespace {
 // and resources loaded.
 bool SubprocessNeedsResourceBundle(const std::string& process_type) {
   return
-#if defined(OS_WIN) || defined(OS_MACOSX)
-      // Windows needs resources for the default/null plugin.
-      // Mac needs them for the plugin process name.
-      process_type == switches::kPluginProcess ||
-#endif
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
       // The zygote process opens the resources for the renderers.
       process_type == switches::kZygoteProcess ||
@@ -80,8 +77,8 @@ MainDelegate::MainDelegate() {
 MainDelegate::~MainDelegate() {
 }
 
-scoped_ptr<ContentClient> MainDelegate::CreateContentClient() {
-  return make_scoped_ptr(new ContentClient);
+std::unique_ptr<ContentClient> MainDelegate::CreateContentClient() {
+  return std::unique_ptr<ContentClient>(new ContentClient);
 }
 
 bool MainDelegate::BasicStartupComplete(int* exit_code) {
@@ -112,8 +109,8 @@ content::ContentBrowserClient* MainDelegate::CreateContentBrowserClient() {
   return browser_client_.get();
 }
 
-scoped_ptr<BrowserClient> MainDelegate::CreateBrowserClient() {
-  return make_scoped_ptr(new BrowserClient);
+std::unique_ptr<BrowserClient> MainDelegate::CreateBrowserClient() {
+  return std::unique_ptr<BrowserClient>(new BrowserClient);
 }
 
 }  // namespace brightray
diff --git a/brightray/common/main_delegate.h b/brightray/common/main_delegate.h
index 2082a5228822..058e553903c7 100644
--- a/brightray/common/main_delegate.h
+++ b/brightray/common/main_delegate.h
@@ -5,8 +5,9 @@
 #ifndef BRIGHTRAY_COMMON_MAIN_DELEGATE_H_
 #define BRIGHTRAY_COMMON_MAIN_DELEGATE_H_
 
-#include "base/compiler_specific.h"
-#include "base/memory/scoped_ptr.h"
+#include <memory>
+
+#include "base/macros.h"
 #include "content/public/app/content_main_delegate.h"
 
 namespace base {
@@ -33,11 +34,11 @@ class MainDelegate : public content::ContentMainDelegate {
  protected:
   // Subclasses can override this to provide their own ContentClient
   // implementation.
-  virtual scoped_ptr<ContentClient> CreateContentClient();
+  virtual std::unique_ptr<ContentClient> CreateContentClient();
 
   // Subclasses can override this to provide their own BrowserClient
   // implementation.
-  virtual scoped_ptr<BrowserClient> CreateBrowserClient();
+  virtual std::unique_ptr<BrowserClient> CreateBrowserClient();
 
 #if defined(OS_MACOSX)
   // Subclasses can override this to custom the paths of child process and
@@ -52,8 +53,8 @@ class MainDelegate : public content::ContentMainDelegate {
  private:
   content::ContentBrowserClient* CreateContentBrowserClient() override;
 
-  scoped_ptr<ContentClient> content_client_;
-  scoped_ptr<BrowserClient> browser_client_;
+  std::unique_ptr<ContentClient> content_client_;
+  std::unique_ptr<BrowserClient> browser_client_;
 
   DISALLOW_COPY_AND_ASSIGN(MainDelegate);
 };
diff --git a/brightray/vendor/libchromiumcontent b/brightray/vendor/libchromiumcontent
index c9e6091e670b..31ff4384348b 160000
--- a/brightray/vendor/libchromiumcontent
+++ b/brightray/vendor/libchromiumcontent
@@ -1 +1 @@
-Subproject commit c9e6091e670bfb7ec2cdee663300674e5727e7aa
+Subproject commit 31ff4384348b139d9e138d4df41b85a11d1a4dbb