[mojo] Expose interface method min_versions

components/arc/instance_holder.h

 // Copyright 2015 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.
 
 #ifndef COMPONENTS_ARC_INSTANCE_HOLDER_H_
 #define COMPONENTS_ARC_INSTANCE_HOLDER_H_
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "base/threading/thread_checker.h"
+#include "mojo/public/cpp/bindings/interface_traits.h"
 
 namespace arc {
 
 // Holds a Mojo instance+version pair. This also allows for listening for state
 // changes for the particular instance. T should be a Mojo interface type
 // (arc::mojom::XxxInstance).
 template <typename T>
 class InstanceHolder {
  public:
   // Notifies about connection events for individual instances.
@@ skipping 31 matching lines @@
     if (version_ < min_version) {
       LOG(ERROR) << "Instance for " << T::Name_
                  << "::" << method_name_for_logging
                  << " version mismatch. Expected " << min_version << " got "
                  << version_;
       return nullptr;
     }
     return instance_;
   }
 
+  template <uint32_t MethodIndex>
+  T* GetInstanceForMethod() {
+    using Method = mojo::MethodTraits<T, MethodIndex>;

[yzshen1, 2016/12/22 18:53:28]

I feel that mojo::MethodTraits is not needed, we could simply do:
const auto& kMethodMetaData = T::kMethodMetadata[MethodIndex];

And then use kMethodMetaData.{name, min_version} below. WDYT?

[yzshen1, 2016/12/22 19:01:09]

But please see my comments in the other file.
If we only have min_version as meta data, we could direct do:

  x->GetInstanceForVersion(kFooMinVersion, "Foo" /* for logging */);

or macro GET_INSTANCE_FOR_VERSION(x, Foo);

+    if (!instance_) {
+      VLOG(1) << "Instance for " << T::Name_ << "::" << Method::Name()
+              << " not available.";
+      return nullptr;
+    }
+    if (version_ < Method::MinVersion()) {
+      LOG(ERROR) << "Instance for " << T::Name_ << "::" << Method::Name()
+                 << " version mismatch. Expected " << Method::MinVersion()
+                 << " got " << version_;
+      return nullptr;
+    }
+    return instance_;
+  }
+
   // Same as the above, but for the version zero.
   T* GetInstanceForMethod(const std::string& method_name_for_logging) {
     return GetInstanceForMethod(method_name_for_logging, 0u);
   }
 
   // Adds or removes observers. This can only be called on the thread that this
   // class was created on. RemoveObserver does nothing if |observer| is not in
   // the list.
   void AddObserver(Observer* observer) {
     DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 39 matching lines @@
 
   base::ThreadChecker thread_checker_;
   base::ObserverList<Observer> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceHolder<T>);
 };
 
 }  // namespace arc
 
 #endif  // COMPONENTS_ARC_INSTANCE_HOLDER_H_