chore: bump chromium to 2a7aff41ce73adc0eeee67d364989 (master) (#18505)

* chore: bump chromium in DEPS to 07463d3cd628b037c11f36022cb4c788db4628e3

* chore: update patches

* fix: Don't leak system network context when nw service is disabled

1632494
NetworkService is now deleted by using SequnceLocalStorageSlot
on the IO thread when the service is disabled, which expects
all associated NetworkContexts on that sequence to be destroyed.

* chore: bump chromium in DEPS to 7c16850e7e40990e141f47101b737ec1092175a1

* fix: Destroy all network contexts before primary network context

* Simplify out-of-process service registration

1615882

* [ThreadPool] Rename base::ThreadPool to base::ThreadPoolInstance

1634851

* chore: update patches

* fix: -Winconsistent-missing-override warnings

* chore: bump chromium in DEPS to 93ebfaccc12715df1d5426797998eed0932f7ae1

* Change CreateBrowserMainParts to return unique_ptrs

1632532

* chore: update patches

* chore: bump chromium in DEPS to e656555ffb87bdd05e248d0a3ef9dd9d3433e17b

* chore: bump chromium in DEPS to 111e7a8d2e3ae9d70e535009d6afb066ac906063

* chore: bump chromium in DEPS to 9b6b84670d32a7aff41ce73adc0eeee67d364989

* chore: update patches

* chore: remove ShouldInterceptResourceAsStream as it is removed upstream

Refs: 1639597

* chore: remove ResourceDispatcherHostCreated as it is removed upstream

Refs: 1610892

* chore: CreateWithStrongBinding --> CreateWithSelfOwnedReceiver

Refs: 1636722

* chore: rename all blink media enums

Refs: 1639237

* chore: add accidentally removed patch content back

atom/browser/atom_browser_client.cc

@@ -79,7 +79,6 @@
 #include "services/device/public/cpp/geolocation/location_provider.h"
 #include "services/network/public/cpp/features.h"
 #include "services/network/public/cpp/resource_request_body.h"
-#include "services/proxy_resolver/public/mojom/proxy_resolver.mojom.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "v8/include/v8.h"
@@ -111,8 +110,6 @@
 
 #if BUILDFLAG(ENABLE_PRINTING)
 #include "chrome/browser/printing/printing_message_filter.h"
-#include "chrome/services/printing/public/mojom/constants.mojom.h"
-#include "components/services/pdf_compositor/public/interfaces/pdf_compositor.mojom.h"
 #endif  // BUILDFLAG(ENABLE_PRINTING)
 
 using content::BrowserThread;
@@ -715,23 +712,6 @@ network::mojom::NetworkContext* AtomBrowserClient::GetSystemNetworkContext() {
   return g_browser_process->system_network_context_manager()->GetContext();
 }
 
-void AtomBrowserClient::RegisterOutOfProcessServices(
-    OutOfProcessServiceMap* services) {
-  (*services)[proxy_resolver::mojom::kProxyResolverServiceName] =
-      base::BindRepeating(&l10n_util::GetStringUTF16,
-                          IDS_UTILITY_PROCESS_PROXY_RESOLVER_NAME);
-
-#if BUILDFLAG(ENABLE_PRINTING)
-  (*services)[printing::mojom::kServiceName] =
-      base::BindRepeating(&l10n_util::GetStringUTF16,
-                          IDS_UTILITY_PROCESS_PDF_COMPOSITOR_SERVICE_NAME);
-
-  (*services)[printing::mojom::kChromePrintingServiceName] =
-      base::BindRepeating(&l10n_util::GetStringUTF16,
-                          IDS_UTILITY_PROCESS_PRINTING_SERVICE_NAME);
-#endif
-}
-
 base::Optional<service_manager::Manifest>
 AtomBrowserClient::GetServiceManifestOverlay(base::StringPiece name) {
   if (name == content::mojom::kBrowserServiceName)
@@ -748,9 +728,10 @@ net::NetLog* AtomBrowserClient::GetNetLog() {
   return g_browser_process->net_log();
 }
 
-content::BrowserMainParts* AtomBrowserClient::CreateBrowserMainParts(
+std::unique_ptr<content::BrowserMainParts>
+AtomBrowserClient::CreateBrowserMainParts(
     const content::MainFunctionParams& params) {
-  return new AtomBrowserMainParts(params);
+  return std::make_unique<AtomBrowserMainParts>(params);
 }
 
 void AtomBrowserClient::WebNotificationAllowed(

atom/browser/atom_browser_client.h

@@ -145,7 +145,6 @@ class AtomBrowserClient : public content::ContentBrowserClient,
       bool in_memory,
       const base::FilePath& relative_partition_path) override;
   network::mojom::NetworkContext* GetSystemNetworkContext() override;
-  void RegisterOutOfProcessServices(OutOfProcessServiceMap* services) override;
   base::Optional<service_manager::Manifest> GetServiceManifestOverlay(
       base::StringPiece name) override;
   std::vector<service_manager::Manifest> GetExtraServiceManifests() override;
@@ -154,7 +153,7 @@ class AtomBrowserClient : public content::ContentBrowserClient,
   content::DevToolsManagerDelegate* GetDevToolsManagerDelegate() override;
   content::PlatformNotificationService* GetPlatformNotificationService(
       content::BrowserContext* browser_context) override;
-  content::BrowserMainParts* CreateBrowserMainParts(
+  std::unique_ptr<content::BrowserMainParts> CreateBrowserMainParts(
       const content::MainFunctionParams&) override;
   base::FilePath GetDefaultDownloadDirectory() override;
   scoped_refptr<network::SharedURLLoaderFactory>

atom/browser/atom_browser_context.cc

@@ -110,11 +110,12 @@ AtomBrowserContext::~AtomBrowserContext() {
   NotifyWillBeDestroyed(this);
   ShutdownStoragePartitions();
 
-  BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE,
-                            std::move(resource_context_));
-
-  if (!base::FeatureList::IsEnabled(network::features::kNetworkService))
+  if (!base::FeatureList::IsEnabled(network::features::kNetworkService)) {
     io_handle_->ShutdownOnUIThread();
+  } else {
+    BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE,
+                              std::move(resource_context_));
+  }
 
   // Notify any keyed services of browser context destruction.
   BrowserContextDependencyManager::GetInstance()->DestroyBrowserContextServices(

atom/browser/atom_resource_dispatcher_host_delegate.cc

@@ -27,80 +27,6 @@ using content::BrowserThread;
 
 namespace atom {
 
-namespace {
-
-#if BUILDFLAG(ENABLE_PDF_VIEWER)
-void OnPdfResourceIntercepted(
-    const GURL& original_url,
-    int render_process_host_id,
-    int render_frame_id,
-    const content::ResourceRequestInfo::WebContentsGetter&
-        web_contents_getter) {
-  content::WebContents* web_contents = web_contents_getter.Run();
-  if (!web_contents)
-    return;
-
-  auto* web_preferences = WebContentsPreferences::From(web_contents);
-  if (!web_preferences || !web_preferences->IsEnabled(options::kPlugins)) {
-    auto* browser_context = web_contents->GetBrowserContext();
-    auto* download_manager =
-        content::BrowserContext::GetDownloadManager(browser_context);
-
-    download_manager->DownloadUrl(
-        content::DownloadUrlParameters::CreateForWebContentsMainFrame(
-            web_contents, original_url, NO_TRAFFIC_ANNOTATION_YET));
-    return;
-  }
-
-  // The URL passes the original pdf resource url, that will be requested
-  // by the webui page.
-  // chrome://pdf-viewer/index.html?src=https://somepage/123.pdf
-  content::NavigationController::LoadURLParams params(GURL(base::StringPrintf(
-      "%sindex.html?%s=%s", kPdfViewerUIOrigin, kPdfPluginSrc,
-      net::EscapeUrlEncodedData(original_url.spec(), false).c_str())));
-
-  content::RenderFrameHost* frame_host =
-      content::RenderFrameHost::FromID(render_process_host_id, render_frame_id);
-  if (!frame_host) {
-    return;
-  }
-
-  params.frame_tree_node_id = frame_host->GetFrameTreeNodeId();
-  web_contents->GetController().LoadURLWithParams(params);
-}
-#endif  // BUILDFLAG(ENABLE_PDF_VIEWER)
-
-}  // namespace
-
 AtomResourceDispatcherHostDelegate::AtomResourceDispatcherHostDelegate() {}
 
-bool AtomResourceDispatcherHostDelegate::ShouldInterceptResourceAsStream(
-    net::URLRequest* request,
-    const std::string& mime_type,
-    GURL* origin,
-    std::string* payload) {
-#if BUILDFLAG(ENABLE_PDF_VIEWER)
-  content::ResourceRequestInfo* info =
-      content::ResourceRequestInfo::ForRequest(request);
-
-  int render_process_host_id;
-  int render_frame_id;
-  if (!info->GetAssociatedRenderFrame(&render_process_host_id,
-                                      &render_frame_id)) {
-    return false;
-  }
-
-  if (mime_type == "application/pdf") {
-    *origin = GURL(kPdfViewerUIOrigin);
-    base::PostTaskWithTraits(
-        FROM_HERE, {BrowserThread::UI},
-        base::BindOnce(&OnPdfResourceIntercepted, request->url(),
-                       render_process_host_id, render_frame_id,
-                       info->GetWebContentsGetterForRequest()));
-    return true;
-  }
-#endif  // BUILDFLAG(ENABLE_PDF_VIEWER)
-  return false;
-}
-
 }  // namespace atom

atom/browser/atom_resource_dispatcher_host_delegate.h

@@ -16,12 +16,6 @@ class AtomResourceDispatcherHostDelegate
  public:
   AtomResourceDispatcherHostDelegate();
 
-  // content::ResourceDispatcherHostDelegate:
-  bool ShouldInterceptResourceAsStream(net::URLRequest* request,
-                                       const std::string& mime_type,
-                                       GURL* origin,
-                                       std::string* payload) override;
-
  private:
   DISALLOW_COPY_AND_ASSIGN(AtomResourceDispatcherHostDelegate);
 };

atom/browser/browser_process_impl.h

@@ -48,7 +48,6 @@ class BrowserProcessImpl : public BrowserProcess {
   void PostDestroyThreads();
   void PostMainMessageLoopRun();
 
-  void ResourceDispatcherHostCreated() override {}
   void EndSession() override {}
   void FlushLocalStateAndReply(base::OnceClosure reply) override {}
   bool IsShuttingDown() override;

atom/browser/io_thread.cc

@@ -6,6 +6,7 @@
 
 #include <utility>
 
+#include "atom/browser/net/url_request_context_getter.h"
 #include "components/net_log/chrome_net_log.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/network_service_instance.h"
@@ -35,6 +36,24 @@ IOThread::~IOThread() {
   BrowserThread::SetIOThreadDelegate(nullptr);
 }
 
+void IOThread::RegisterURLRequestContextGetter(
+    atom::URLRequestContextGetter* getter) {
+  base::AutoLock lock(lock_);
+
+  DCHECK(!base::FeatureList::IsEnabled(network::features::kNetworkService));
+  DCHECK_EQ(0u, request_context_getters_.count(getter));
+  request_context_getters_.insert(getter);
+}
+
+void IOThread::DeregisterURLRequestContextGetter(
+    atom::URLRequestContextGetter* getter) {
+  base::AutoLock lock(lock_);
+
+  DCHECK(!base::FeatureList::IsEnabled(network::features::kNetworkService));
+  DCHECK_EQ(1u, request_context_getters_.count(getter));
+  request_context_getters_.erase(getter);
+}
+
 void IOThread::Init() {
   if (!base::FeatureList::IsEnabled(network::features::kNetworkService)) {
     std::unique_ptr<network::URLRequestContextBuilderMojo> builder =
@@ -55,20 +74,24 @@ void IOThread::Init() {
     network_service->ConfigureHttpAuthPrefs(
         std::move(http_auth_dynamic_params_));
 
-    system_network_context_ =
-        network_service
-            ->CreateNetworkContextWithBuilder(
-                std::move(network_context_request_),
-                std::move(network_context_params_), std::move(builder),
-                &system_request_context_)
-            .release();
+    system_network_context_ = network_service->CreateNetworkContextWithBuilder(
+        std::move(network_context_request_), std::move(network_context_params_),
+        std::move(builder), &system_request_context_);
   }
 }
 
 void IOThread::CleanUp() {
-  if (!base::FeatureList::IsEnabled(network::features::kNetworkService))
+  if (!base::FeatureList::IsEnabled(network::features::kNetworkService)) {
     system_request_context_->proxy_resolution_service()->OnShutdown();
 
+    base::AutoLock lock(lock_);
+    for (auto* getter : request_context_getters_) {
+      getter->NotifyContextShuttingDown();
+    }
+
+    system_network_context_.reset();
+  }
+
   if (net_log_)
     net_log_->ShutDownBeforeThreadPool();
 }

atom/browser/io_thread.h

@@ -6,12 +6,18 @@
 #define ATOM_BROWSER_IO_THREAD_H_
 
 #include <memory>
+#include <set>
 
 #include "atom/browser/net/system_network_context_manager.h"
 #include "base/macros.h"
+#include "base/synchronization/lock.h"
 #include "content/public/browser/browser_thread_delegate.h"
 #include "services/network/public/mojom/network_service.mojom.h"
 
+namespace atom {
+class URLRequestContextGetter;
+}
+
 namespace net {
 class URLRequestContext;
 }
@@ -27,6 +33,9 @@ class IOThread : public content::BrowserThreadDelegate {
       SystemNetworkContextManager* system_network_context_manager);
   ~IOThread() override;
 
+  void RegisterURLRequestContextGetter(atom::URLRequestContextGetter* getter);
+  void DeregisterURLRequestContextGetter(atom::URLRequestContextGetter* getter);
+
  protected:
   // BrowserThreadDelegate Implementation, runs on the IO thread.
   void Init() override;
@@ -39,13 +48,7 @@ class IOThread : public content::BrowserThreadDelegate {
 
   // When the network service is disabled, this holds on to a
   // content::NetworkContext class that owns |system_request_context_|.
-  // TODO(deepak1556): primary network context has to be destroyed after
-  // other active contexts, but since the ownership of latter is not released
-  // before IO thread is destroyed, it results in a DCHECK failure.
-  // We leak the reference to primary context to workaround this issue,
-  // since there is only one instance for the entire lifetime of app, it is
-  // safe.
-  network::mojom::NetworkContext* system_network_context_;
+  std::unique_ptr<network::mojom::NetworkContext> system_network_context_;
   net::URLRequestContext* system_request_context_;
 
   // These are set on the UI thread, and then consumed during initialization on
@@ -59,6 +62,13 @@ class IOThread : public content::BrowserThreadDelegate {
   network::mojom::HttpAuthStaticParamsPtr http_auth_static_params_;
   network::mojom::HttpAuthDynamicParamsPtr http_auth_dynamic_params_;
 
+  // |lock_| protects access to |request_context_getters_|.
+  base::Lock lock_;
+
+  // List of all request contexts that needs to be notified when
+  // IO thread is shutting down.
+  std::set<atom::URLRequestContextGetter*> request_context_getters_;
+
   DISALLOW_COPY_AND_ASSIGN(IOThread);
 };
 

atom/browser/media/media_stream_devices_controller.cc

@@ -42,9 +42,10 @@ MediaStreamDevicesController::MediaStreamDevicesController(
 
 MediaStreamDevicesController::~MediaStreamDevicesController() {
   if (!callback_.is_null()) {
-    std::move(callback_).Run(blink::MediaStreamDevices(),
-                             blink::MEDIA_DEVICE_FAILED_DUE_TO_SHUTDOWN,
-                             std::unique_ptr<content::MediaStreamUI>());
+    std::move(callback_).Run(
+        blink::MediaStreamDevices(),
+        blink::mojom::MediaStreamRequestResult::FAILED_DUE_TO_SHUTDOWN,
+        std::unique_ptr<content::MediaStreamUI>());
   }
 }
 
@@ -60,7 +61,7 @@ bool MediaStreamDevicesController::TakeAction() {
 
   // Deny the request if there is no device attached to the OS.
   if (!HasAnyAvailableDevice()) {
-    Deny(blink::MEDIA_DEVICE_NO_HARDWARE);
+    Deny(blink::mojom::MediaStreamRequestResult::NO_HARDWARE);
     return true;
   }
 
@@ -146,12 +147,12 @@ void MediaStreamDevicesController::Accept() {
     }
   }
 
-  std::move(callback_).Run(devices, blink::MEDIA_DEVICE_OK,
+  std::move(callback_).Run(devices, blink::mojom::MediaStreamRequestResult::OK,
                            std::unique_ptr<content::MediaStreamUI>());
 }
 
 void MediaStreamDevicesController::Deny(
-    blink::MediaStreamRequestResult result) {
+    blink::mojom::MediaStreamRequestResult result) {
   std::move(callback_).Run(blink::MediaStreamDevices(), result,
                            std::unique_ptr<content::MediaStreamUI>());
 }
@@ -188,10 +189,11 @@ void MediaStreamDevicesController::HandleUserMediaRequest() {
                                  screen_id.ToString(), "Screen"));
   }
 
-  std::move(callback_).Run(devices,
-                           devices.empty() ? blink::MEDIA_DEVICE_NO_HARDWARE
-                                           : blink::MEDIA_DEVICE_OK,
-                           std::unique_ptr<content::MediaStreamUI>());
+  std::move(callback_).Run(
+      devices,
+      devices.empty() ? blink::mojom::MediaStreamRequestResult::NO_HARDWARE
+                      : blink::mojom::MediaStreamRequestResult::OK,
+      std::unique_ptr<content::MediaStreamUI>());
 }
 
 }  // namespace atom

atom/browser/media/media_stream_devices_controller.h

@@ -22,7 +22,7 @@ class MediaStreamDevicesController {
 
   // Explicitly accept or deny the request.
   void Accept();
-  void Deny(blink::MediaStreamRequestResult result);
+  void Deny(blink::mojom::MediaStreamRequestResult result);
 
  private:
   // Handle the request of desktop or tab screen cast.

atom/browser/net/system_network_context_manager.cc

@@ -176,7 +176,7 @@ SystemNetworkContextManager::CreateDefaultNetworkContextParams() {
   network_context_params->enable_referrers = true;
 
   network_context_params->proxy_resolver_factory =
-      ChromeMojoProxyResolverFactory::CreateWithStrongBinding().PassInterface();
+      ChromeMojoProxyResolverFactory::CreateWithSelfOwnedReceiver();
 
   return network_context_params;
 }

atom/browser/net/url_request_context_getter.cc

@@ -128,9 +128,13 @@ URLRequestContextGetter::Handle::CreateMainRequestContextGetter(
     content::URLRequestInterceptorScopedVector protocol_interceptors) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!main_request_context_getter_.get());
+  DCHECK(g_browser_process->io_thread());
+
   LazyInitialize();
   main_request_context_getter_ = new URLRequestContextGetter(
       this, protocol_handlers, std::move(protocol_interceptors));
+  g_browser_process->io_thread()->RegisterURLRequestContextGetter(
+      main_request_context_getter_.get());
   return main_request_context_getter_;
 }
 
@@ -209,13 +213,13 @@ void URLRequestContextGetter::Handle::LazyInitialize() {
 
 void URLRequestContextGetter::Handle::ShutdownOnUIThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (main_request_context_getter_.get()) {
+
+  if (main_request_context_getter_) {
     if (BrowserThread::IsThreadInitialized(BrowserThread::IO)) {
       base::PostTaskWithTraits(
           FROM_HERE, {BrowserThread::IO},
           base::BindOnce(&URLRequestContextGetter::NotifyContextShuttingDown,
-                         base::RetainedRef(main_request_context_getter_),
-                         std::move(resource_context_)));
+                         base::RetainedRef(main_request_context_getter_)));
     }
   }
 
@@ -244,18 +248,20 @@ URLRequestContextGetter::~URLRequestContextGetter() {
   DCHECK(context_shutting_down_);
 }
 
-void URLRequestContextGetter::NotifyContextShuttingDown(
-    std::unique_ptr<content::ResourceContext> resource_context) {
+void URLRequestContextGetter::NotifyContextShuttingDown() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(g_browser_process->io_thread());
+  DCHECK(context_handle_);
 
-  // todo(brenca): remove once C70 lands
-  if (url_request_context_ && url_request_context_->cookie_store()) {
-    url_request_context_->cookie_store()->FlushStore(base::NullCallback());
-  }
+  if (context_shutting_down_)
+    return;
+
+  g_browser_process->io_thread()->DeregisterURLRequestContextGetter(this);
 
   context_shutting_down_ = true;
-  resource_context.reset();
+  context_handle_->resource_context_.reset();
   net::URLRequestContextGetter::NotifyContextShuttingDown();
+  network_context_.reset();
 }
 
 net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {

atom/browser/net/url_request_context_getter.h

@@ -37,7 +37,7 @@ class URLRequestContextGetter : public net::URLRequestContextGetter {
 
   // Discard reference to URLRequestContext and inform observers to
   // shutdown. Must be called only on IO thread.
-  void NotifyContextShuttingDown(std::unique_ptr<content::ResourceContext>);
+  void NotifyContextShuttingDown();
 
   AtomURLRequestJobFactory* job_factory() const {
     return top_job_factory_.get();

atom/browser/notifications/win/windows_toast_notification.h

@@ -112,13 +112,13 @@ class ToastEventHandler : public RuntimeClass<RuntimeClassFlags<ClassicCom>,
 
   IFACEMETHODIMP Invoke(
       ABI::Windows::UI::Notifications::IToastNotification* sender,
-      IInspectable* args);
+      IInspectable* args) override;
   IFACEMETHODIMP Invoke(
       ABI::Windows::UI::Notifications::IToastNotification* sender,
-      ABI::Windows::UI::Notifications::IToastDismissedEventArgs* e);
+      ABI::Windows::UI::Notifications::IToastDismissedEventArgs* e) override;
   IFACEMETHODIMP Invoke(
       ABI::Windows::UI::Notifications::IToastNotification* sender,
-      ABI::Windows::UI::Notifications::IToastFailedEventArgs* e);
+      ABI::Windows::UI::Notifications::IToastFailedEventArgs* e) override;
 
  private:
   base::WeakPtr<Notification> notification_;  // weak ref.

atom/browser/web_contents_permission_helper.cc

@@ -40,7 +40,7 @@ void MediaAccessAllowed(const content::MediaStreamRequest& request,
   if (allowed)
     controller.TakeAction();
   else
-    controller.Deny(blink::MEDIA_DEVICE_PERMISSION_DENIED);
+    controller.Deny(blink::mojom::MediaStreamRequestResult::PERMISSION_DENIED);
 }
 
 void OnPointerLockResponse(content::WebContents* web_contents, bool allowed) {