Eliminate bind callback that doesn't take a BindSourceInfo parameter.

chrome/utility/chrome_content_utility_client.cc

 // 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 "chrome/utility/chrome_content_utility_client.h"
 
 #include <stddef.h>
 #include <utility>
 #include <vector>
 
@@ skipping 54 matching lines @@
 #endif
 #endif
 
 namespace {
 
 class FilePatcherImpl : public chrome::mojom::FilePatcher {
  public:
   FilePatcherImpl() = default;
   ~FilePatcherImpl() override = default;
 
-  static void Create(chrome::mojom::FilePatcherRequest request) {
+  static void Create(const service_manager::BindSourceInfo& source_info,
+                     chrome::mojom::FilePatcherRequest request) {
     mojo::MakeStrongBinding(base::MakeUnique<FilePatcherImpl>(),
                             std::move(request));
   }
 
  private:
   // chrome::mojom::FilePatcher:
   void PatchFileBsdiff(base::File input_file,
                        base::File patch_file,
                        base::File output_file,
                        const PatchFileBsdiffCallback& callback) override {
@@ skipping 21 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(FilePatcherImpl);
 };
 
 #if defined(OS_CHROMEOS)
 class ZipFileCreatorImpl : public chrome::mojom::ZipFileCreator {
  public:
   ZipFileCreatorImpl() = default;
   ~ZipFileCreatorImpl() override = default;
 
-  static void Create(chrome::mojom::ZipFileCreatorRequest request) {
+  static void Create(const service_manager::BindSourceInfo& source_info,
+                     chrome::mojom::ZipFileCreatorRequest request) {
     mojo::MakeStrongBinding(base::MakeUnique<ZipFileCreatorImpl>(),
                             std::move(request));
   }
 
  private:
   // chrome::mojom::ZipFileCreator:
   void CreateZipFile(const base::FilePath& source_dir,
                      const std::vector<base::FilePath>& source_relative_paths,
                      base::File zip_file,
                      const CreateZipFileCallback& callback) override {
@@ skipping 13 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ZipFileCreatorImpl);
 };
 #endif  // defined(OS_CHROMEOS)
 
 #if defined(FULL_SAFE_BROWSING)
 class SafeArchiveAnalyzerImpl : public chrome::mojom::SafeArchiveAnalyzer {
  public:
   SafeArchiveAnalyzerImpl() = default;
   ~SafeArchiveAnalyzerImpl() override = default;
 
-  static void Create(chrome::mojom::SafeArchiveAnalyzerRequest request) {
+  static void Create(const service_manager::BindSourceInfo& source_info,
+                     chrome::mojom::SafeArchiveAnalyzerRequest request) {
     mojo::MakeStrongBinding(base::MakeUnique<SafeArchiveAnalyzerImpl>(),
                             std::move(request));
   }
 
  private:
   // chrome::mojom::SafeArchiveAnalyzer:
   void AnalyzeZipFile(base::File zip_file,
                       base::File temporary_file,
                       const AnalyzeZipFileCallback& callback) override {
     DCHECK(temporary_file.IsValid());
@@ skipping 16 matching lines @@
     NOTREACHED();
 #endif
   }
 
   DISALLOW_COPY_AND_ASSIGN(SafeArchiveAnalyzerImpl);
 };
 #endif  // defined(FULL_SAFE_BROWSING)
 
 #if !defined(OS_ANDROID)
 void CreateProxyResolverFactory(
+    const service_manager::BindSourceInfo& source_info,
     net::interfaces::ProxyResolverFactoryRequest request) {
   mojo::MakeStrongBinding(base::MakeUnique<net::MojoProxyResolverFactoryImpl>(),
                           std::move(request));
 }
 
 class ResourceUsageReporterImpl : public chrome::mojom::ResourceUsageReporter {
  public:
   ResourceUsageReporterImpl() {}
   ~ResourceUsageReporterImpl() override {}
 
  private:
   void GetUsageData(const GetUsageDataCallback& callback) override {
     chrome::mojom::ResourceUsageDataPtr data =
         chrome::mojom::ResourceUsageData::New();
     size_t total_heap_size = net::ProxyResolverV8::GetTotalHeapSize();
     if (total_heap_size) {
       data->reports_v8_stats = true;
       data->v8_bytes_allocated = total_heap_size;
       data->v8_bytes_used = net::ProxyResolverV8::GetUsedHeapSize();
     }
     callback.Run(std::move(data));
   }
 
   DISALLOW_COPY_AND_ASSIGN(ResourceUsageReporterImpl);
 };
 
 void CreateResourceUsageReporter(
-    mojo::InterfaceRequest<chrome::mojom::ResourceUsageReporter> request) {
+    const service_manager::BindSourceInfo& source_info,
+    chrome::mojom::ResourceUsageReporterRequest request) {
   mojo::MakeStrongBinding(base::MakeUnique<ResourceUsageReporterImpl>(),
                           std::move(request));
 }
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace
 
 ChromeContentUtilityClient::ChromeContentUtilityClient()
     : utility_process_running_elevated_(false) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
@@ skipping 88 matching lines @@
 
   return false;
 }
 
 // static
 void ChromeContentUtilityClient::PreSandboxStartup() {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   extensions::ExtensionsHandler::PreSandboxStartup();
 #endif
 }