Add protocol APIs to CommandDispatcher.

ios/shared/chrome/browser/ui/commands/command_dispatcher.mm

 // Copyright 2017 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.
 
 #import "ios/shared/chrome/browser/ui/commands/command_dispatcher.h"
 
+#include <objc/runtime.h>
 #include <unordered_map>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/strings/sys_string_conversions.h"
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
 #endif
 
 @implementation CommandDispatcher {
   // Stores which target to forward to for a given selector.
   std::unordered_map<SEL, __weak id> _forwardingTargets;
 }
 
 - (void)startDispatchingToTarget:(id)target forSelector:(SEL)selector {
   DCHECK(_forwardingTargets.find(selector) == _forwardingTargets.end());
 
   _forwardingTargets[selector] = target;
 }
 
+- (void)startDispatchingToTarget:(id)target forProtocol:(Protocol*)protocol {
+  unsigned int outCount;

[marq (ping after 24h), 2017/03/30 14:03:55]

Prefer method_count, here and below.

[lpromero, 2017/03/30 15:00:39]

Would methodCount work?

[marq (ping after 24h), 2017/03/31 07:43:01]

Yes, sorry; I'm working on similar code inside a C function, so I had
snake_style in my head.

[lpromero, 2017/04/04 13:08:52]

Done.

+  objc_method_description* requiredInstanceMethods =
+      protocol_copyMethodDescriptionList(protocol, YES /* isRequiredMethod */,
+                                         YES /* isInstanceMethod */, &outCount);
+  for (unsigned int i = 0; i < outCount; i++) {
+    [self startDispatchingToTarget:target
+                       forSelector:requiredInstanceMethods[i].name];
+  }

[marq (ping after 24h), 2017/03/30 14:03:55]

What about protocols the protocol adheres to? (with the wrinkle that we don't
want to start dispatching <NSObject>, for example).

[lpromero, 2017/03/30 15:00:39]

I started this CL to basically raise all these questions. Do we support:
- the properties
- the class methods
- the optional methods
- the parent protocol methods?

Instead, shouldn't we try to be explicit everywhere we register for method
dispatch? The protocol API makes a lot of things implicit and hard to follow.
Where do you see us using this CL?

[marq (ping after 24h), 2017/03/31 07:43:01]

Clearly either of these calls are just conveniences to reduce boilerplate, so
it's possible that they open a can of worms that's not worth figuring out. On
the other hand, we may be able to say that all command protocols are just
required methods with no inheritance or anything else. So maybe we start with
this as-is and see if it does useful work, and then we can assess if making them
handle all of the edge cases is worth the convenience they provide.

[lpromero, 2017/04/04 13:08:52]

Done.

+}
+
 - (void)stopDispatchingForSelector:(SEL)selector {
   _forwardingTargets.erase(selector);
 }
 
+- (void)stopDispatchingForProtocol:(Protocol*)protocol {
+  unsigned int outCount;
+  objc_method_description* requiredInstanceMethods =
+      protocol_copyMethodDescriptionList(protocol, YES /* isRequiredMethod */,
+                                         YES /* isInstanceMethod */, &outCount);
+  for (unsigned int i = 0; i < outCount; i++) {
+    [self stopDispatchingForSelector:requiredInstanceMethods[i].name];
+  }
+}
+
 // |-stopDispatchingToTarget| should be called much less often than
 // |-forwardingTargetForSelector|, so removal is intentionally O(n) in order
 // to prioritize the speed of lookups.
 - (void)stopDispatchingToTarget:(id)target {
   std::vector<SEL> selectorsToErase;
   for (auto& kv : _forwardingTargets) {
     if (kv.second == target) {
       selectorsToErase.push_back(kv.first);
     }
   }
 
   for (auto* selector : selectorsToErase) {
     [self stopDispatchingForSelector:selector];
   }
 }
 
 #pragma mark - NSObject
 
 // Overridden to forward messages to registered handlers.
 - (id)forwardingTargetForSelector:(SEL)selector {
   auto target = _forwardingTargets.find(selector);
   if (target != _forwardingTargets.end()) {
     return target->second;
   }
   return [super forwardingTargetForSelector:selector];
 }
 
 @end