Trim down functionality in mojo::AssociatedInterfacePtrInfo.

At this point, this is just a helper class for conveying info when
binding and unbinding an associated remote endpoint, so remove all other
functionality.

Bug: 875030, 955171
Change-Id: I7711b97deb306536fe4951f5a575ef1231c2ebec
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3527063
Reviewed-by: Ken Rockot <[email protected]>
Commit-Queue: Daniel Cheng <[email protected]>
Cr-Commit-Position: refs/heads/main@{#982544}

Author: zetafunction

PRESUBMIT.py

@@ -1015,19 +1015,6 @@ class BanRule:
     ),
 )
 
-# Format: Sequence of tuples containing:
-# * String pattern or, if starting with a slash, a regular expression.
-# * Sequence of strings to show when the pattern matches.
-_DEPRECATED_MOJO_TYPES : Sequence[BanRule] = (
-    BanRule(
-      r'/\bmojo::AssociatedInterfacePtrInfo\b',
-      (
-        'mojo::AssociatedInterfacePtrInfo<Interface> is deprecated.',
-        'Use mojo::PendingAssociatedRemote<Interface> instead.',
-      ),
-    ),
-)
-
 _IPC_ENUM_TRAITS_DEPRECATED = (
     'You are using IPC_ENUM_TRAITS() in your code. It has been deprecated.\n'
     'See http://www.chromium.org/Home/chromium-security/education/'
@@ -1733,48 +1720,6 @@ def _CheckAndroidNoBannedImports(input_api, output_api):
     return result
 
 
-def CheckNoDeprecatedMojoTypes(input_api, output_api):
-    """Make sure that old Mojo types are not used."""
-    warnings = []
-    errors = []
-
-    # For any path that is not an "ok" or an "error" path, a warning will be
-    # raised if deprecated mojo types are found.
-    ok_paths = ['components/arc']
-    error_paths = ['third_party/blink', 'content']
-
-    file_filter = lambda f: f.LocalPath().endswith(('.cc', '.mm', '.h'))
-    for f in input_api.AffectedFiles(file_filter=file_filter):
-        # Don't check //components/arc, not yet migrated (see crrev.com/c/1868870).
-        if any(map(lambda path: f.LocalPath().startswith(path), ok_paths)):
-            continue
-
-        for line_num, line in f.ChangedContents():
-            for ban_rule in _DEPRECATED_MOJO_TYPES:
-                problems = _GetMessageForMatchingType(input_api, f, line_num,
-                                                      line, ban_rule)
-
-                if problems:
-                    # Raise errors inside |error_paths| and warnings everywhere else.
-                    if any(
-                            map(lambda path: f.LocalPath().startswith(path),
-                                error_paths)):
-                        errors.extend(problems)
-                    else:
-                        warnings.extend(problems)
-
-    result = []
-    if (warnings):
-        result.append(
-            output_api.PresubmitPromptWarning(
-                'Banned Mojo types were used.\n' + '\n'.join(warnings)))
-    if (errors):
-        result.append(
-            output_api.PresubmitError('Banned Mojo types were used.\n' +
-                                      '\n'.join(errors)))
-    return result
-
-
 def CheckNoPragmaOnce(input_api, output_api):
     """Make sure that banned functions are not used."""
     files = []

PRESUBMIT_test.py

@@ -2613,74 +2613,6 @@ def testBannedMojomPatterns(self):
     self.assertTrue('bad.mojom' in results[0].message)
     self.assertTrue('good.mojom' not in results[0].message)
 
-  def testDeprecatedMojoTypes(self):
-    ok_paths = ['components/arc']
-    warning_paths = ['some/cpp']
-    error_paths = ['third_party/blink', 'content']
-    test_cases = [
-      {
-        'type': 'mojo::AssociatedInterfacePtrInfo<>',
-        'file': 'file4.cc'
-      },
-      {
-        'type': 'mojo::AssociatedInterfaceRequest<>',
-        'file': 'file5.cc'
-      },
-      {
-        'type': 'mojo::InterfacePtr<>',
-        'file': 'file8.cc'
-      },
-      {
-        'type': 'mojo::InterfacePtrInfo<>',
-        'file': 'file9.cc'
-      },
-      {
-        'type': 'mojo::InterfaceRequest<>',
-        'file': 'file10.cc'
-      },
-      {
-        'type': 'mojo::MakeRequest()',
-        'file': 'file11.cc'
-      },
-    ]
-
-    # Build the list of MockFiles considering paths that should trigger warnings
-    # as well as paths that should trigger errors.
-    input_api = MockInputApi()
-    input_api.files = []
-    for test_case in test_cases:
-      for path in ok_paths:
-        input_api.files.append(MockFile(os.path.join(path, test_case['file']),
-                                        [test_case['type']]))
-      for path in warning_paths:
-        input_api.files.append(MockFile(os.path.join(path, test_case['file']),
-                                        [test_case['type']]))
-      for path in error_paths:
-        input_api.files.append(MockFile(os.path.join(path, test_case['file']),
-                                        [test_case['type']]))
-
-    results = PRESUBMIT.CheckNoDeprecatedMojoTypes(input_api, MockOutputApi())
-
-    # warnings are results[0], errors are results[1]
-    self.assertEqual(2, len(results))
-
-    for test_case in test_cases:
-      # Check that no warnings nor errors have been triggered for these paths.
-      for path in ok_paths:
-        self.assertFalse(path in results[0].message)
-        self.assertFalse(path in results[1].message)
-
-      # Check warnings have been triggered for these paths.
-      for path in warning_paths:
-        self.assertTrue(path in results[0].message)
-        self.assertFalse(path in results[1].message)
-
-      # Check errors have been triggered for these paths.
-      for path in error_paths:
-        self.assertFalse(path in results[0].message)
-        self.assertTrue(path in results[1].message)
-
-
 class NoProductionCodeUsingTestOnlyFunctionsTest(unittest.TestCase):
   def testTruePositives(self):
     mock_input_api = MockInputApi()

mojo/public/cpp/bindings/associated_interface_ptr_info.h

@@ -24,13 +24,9 @@ namespace mojo {
 template <typename Interface>
 class AssociatedInterfacePtrInfo {
  public:
-  AssociatedInterfacePtrInfo() : version_(0u) {}
-  AssociatedInterfacePtrInfo(std::nullptr_t) : version_(0u) {}
-
   AssociatedInterfacePtrInfo(AssociatedInterfacePtrInfo&& other)
-      : handle_(std::move(other.handle_)), version_(other.version_) {
-    other.version_ = 0u;
-  }
+      : handle_(std::move(other.handle_)),
+        version_(std::exchange(other.version_, 0u)) {}
 
   AssociatedInterfacePtrInfo(ScopedInterfaceEndpointHandle handle,
                              uint32_t version)
@@ -45,36 +41,16 @@ class AssociatedInterfacePtrInfo {
   AssociatedInterfacePtrInfo& operator=(AssociatedInterfacePtrInfo&& other) {
     if (this != &other) {
       handle_ = std::move(other.handle_);
-      version_ = other.version_;
-      other.version_ = 0u;
+      version_ = std::exchange(other.version_, 0u);
     }
 
     return *this;
   }
 
   bool is_valid() const { return handle_.is_valid(); }
 
-  explicit operator bool() const { return handle_.is_valid(); }
-
-  ScopedInterfaceEndpointHandle PassHandle() {
-    return std::move(handle_);
-  }
-  const ScopedInterfaceEndpointHandle& handle() const { return handle_; }
-  void set_handle(ScopedInterfaceEndpointHandle handle) {
-    handle_ = std::move(handle);
-  }
-
+  ScopedInterfaceEndpointHandle PassHandle() { return std::move(handle_); }
   uint32_t version() const { return version_; }
-  void set_version(uint32_t version) { version_ = version; }
-
-  bool Equals(const AssociatedInterfacePtrInfo& other) const {
-    if (this == &other)
-      return true;
-
-    // Now that the two refer to different objects, they are equivalent if
-    // and only if they are both invalid.
-    return !is_valid() && !other.is_valid();
-  }
 
  private:
   ScopedInterfaceEndpointHandle handle_;

mojo/public/cpp/bindings/deprecated_interface_types_forward.h

@@ -8,8 +8,6 @@
 // Forward declarations which foo.mojom-forward.h requires.
 namespace mojo {
 
-template <typename Interface>
-class InterfacePtrInfo;
 template <typename Interface>
 class AssociatedInterfacePtrInfo;
 

mojo/public/cpp/bindings/lib/interface_serialization.h

@@ -26,33 +26,6 @@ class Message;
 
 namespace internal {
 
-template <typename Base, typename T>
-struct Serializer<AssociatedInterfacePtrInfoDataView<Base>,
-                  AssociatedInterfacePtrInfo<T>> {
-  static_assert(std::is_base_of<Base, T>::value, "Interface type mismatch.");
-
-  static void Serialize(AssociatedInterfacePtrInfo<T>& input,
-                        AssociatedInterface_Data* output,
-                        Message* message) {
-    DCHECK(!input.handle().is_valid() || input.handle().pending_association());
-    SerializeAssociatedInterfaceInfo(input.PassHandle(), input.version(),
-                                     *message, *output);
-  }
-
-  static bool Deserialize(AssociatedInterface_Data* input,
-                          AssociatedInterfacePtrInfo<T>* output,
-                          Message* message) {
-    auto handle = DeserializeAssociatedEndpointHandle(input->handle, *message);
-    if (!handle.is_valid()) {
-      *output = AssociatedInterfacePtrInfo<T>();
-    } else {
-      output->set_handle(std::move(handle));
-      output->set_version(input->version);
-    }
-    return true;
-  }
-};
-
 template <typename Base, typename T>
 struct Serializer<AssociatedInterfacePtrInfoDataView<Base>,
                   PendingAssociatedRemote<T>> {

mojo/public/cpp/bindings/pending_associated_remote.h

@@ -37,11 +37,6 @@ class PendingAssociatedRemote {
                           uint32_t version)
       : handle_(std::move(handle)), version_(version) {}
 
-  // Temporary helper for transitioning away from old types. Intentionally an
-  // implicit constructor.
-  PendingAssociatedRemote(AssociatedInterfacePtrInfo<Interface>&& ptr_info)
-      : PendingAssociatedRemote(ptr_info.PassHandle(), ptr_info.version()) {}
-
   // Disabled on NaCl since it crashes old version of clang.
 #if !BUILDFLAG(IS_NACL)
   // Move conversion operator for custom remote types. Only participates in
@@ -74,12 +69,6 @@ class PendingAssociatedRemote {
 
   void reset() { handle_.reset(); }
 
-  // Temporary helper for transitioning away from old bindings types. This is
-  // intentionally an implicit conversion.
-  operator AssociatedInterfacePtrInfo<Interface>() {
-    return AssociatedInterfacePtrInfo<Interface>(PassHandle(), version());
-  }
-
   ScopedInterfaceEndpointHandle PassHandle() { return std::move(handle_); }
   const ScopedInterfaceEndpointHandle& handle() const { return handle_; }
   void set_handle(ScopedInterfaceEndpointHandle handle) {