[not for commit (yet)] inline more things but doesn't seem to improve perf

mojo/public/cpp/bindings/lib/validation_util.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 MOJO_PUBLIC_CPP_BINDINGS_LIB_VALIDATION_UTIL_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_VALIDATION_UTIL_H_
 
 #include <stdint.h>
 
 #include "mojo/public/cpp/bindings/lib/bindings_internal.h"
@@ skipping 40 matching lines @@
 
 // Validates that |data| contains a valid union header, in terms of alignment
 // and size. If not inlined, it checks that the memory range
 // [data, data + num_bytes) is not marked as occupied by other objects in
 // |validation_context|. On success, the memory range is marked as occupied.
 bool ValidateUnionHeaderAndClaimMemory(const void* data,
                                        bool inlined,
                                        ValidationContext* validation_context);
 
 // Validates that the message is a request which doesn't expect a response.
-bool ValidateMessageIsRequestWithoutResponse(
+inline bool ValidateMessageIsRequestWithoutResponse(
     const Message* message,
-    ValidationContext* validation_context);
+    ValidationContext* validation_context) {
+  if (message->has_flag(Message::kFlagIsResponse) ||
+      message->has_flag(Message::kFlagExpectsResponse)) {
+    ReportValidationError(validation_context,
+                          VALIDATION_ERROR_MESSAGE_HEADER_INVALID_FLAGS);
+    return false;
+  }
+  return true;
+}
 
 // Validates that the message is a request expecting a response.
-bool ValidateMessageIsRequestExpectingResponse(
+inline bool ValidateMessageIsRequestExpectingResponse(
     const Message* message,
-    ValidationContext* validation_context);
+    ValidationContext* validation_context) {
+  if (message->has_flag(Message::kFlagIsResponse) ||
+      !message->has_flag(Message::kFlagExpectsResponse)) {
+    ReportValidationError(validation_context,
+                          VALIDATION_ERROR_MESSAGE_HEADER_INVALID_FLAGS);
+    return false;
+  }
+  return true;
+}
 
 // Validates that the message is a response.
-bool ValidateMessageIsResponse(const Message* message,
-                               ValidationContext* validation_context);
+inline bool ValidateMessageIsResponse(const Message* message,
+                                      ValidationContext* validation_context) {
+  if (message->has_flag(Message::kFlagExpectsResponse) ||
+      !message->has_flag(Message::kFlagIsResponse)) {
+    ReportValidationError(validation_context,
+                          VALIDATION_ERROR_MESSAGE_HEADER_INVALID_FLAGS);
+    return false;
+  }
+  return true;
+}
 
 // Validates that the message payload is a valid struct of type ParamsType.
 template <typename ParamsType>
 bool ValidateMessagePayload(const Message* message,
                             ValidationContext* validation_context) {
   return ParamsType::Validate(message->payload(), validation_context);
 }
 
 // The following methods validate control messages defined in
 // interface_control_messages.mojom.
@@ skipping 23 matching lines @@
                                      ValidationContext* validation_context) {
   if (!input.is_null())
     return true;
 
   ReportValidationError(validation_context,
                         VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
                         error_message);
   return false;
 }
 
-bool IsHandleOrInterfaceValid(const AssociatedInterface_Data& input);
-bool IsHandleOrInterfaceValid(const AssociatedInterfaceRequest_Data& input);
-bool IsHandleOrInterfaceValid(const Interface_Data& input);
-bool IsHandleOrInterfaceValid(const Handle_Data& input);
+inline bool IsHandleOrInterfaceValid(const AssociatedInterface_Data& input) {
+  return IsValidInterfaceId(input.interface_id);
+}
 
-bool ValidateHandleOrInterfaceNonNullable(
+inline bool IsHandleOrInterfaceValid(
+    const AssociatedInterfaceRequest_Data& input) {
+  return IsValidInterfaceId(input.interface_id);
+}
+
+inline bool IsHandleOrInterfaceValid(const Interface_Data& input) {
+  return input.handle.is_valid();
+}
+
+inline bool IsHandleOrInterfaceValid(const Handle_Data& input) {
+  return input.is_valid();
+}
+
+inline bool ValidateHandleOrInterfaceNonNullable(
     const AssociatedInterface_Data& input,
     const char* error_message,
-    ValidationContext* validation_context);
-bool ValidateHandleOrInterfaceNonNullable(
+    ValidationContext* validation_context) {
+  if (IsHandleOrInterfaceValid(input))
+    return true;
+
+  ReportValidationError(validation_context,
+                        VALIDATION_ERROR_UNEXPECTED_INVALID_INTERFACE_ID,
+                        error_message);
+  return false;
+}
+
+inline bool ValidateHandleOrInterfaceNonNullable(
     const AssociatedInterfaceRequest_Data& input,
     const char* error_message,
-    ValidationContext* validation_context);
-bool ValidateHandleOrInterfaceNonNullable(
+    ValidationContext* validation_context) {
+  if (IsHandleOrInterfaceValid(input))
+    return true;
+
+  ReportValidationError(validation_context,
+                        VALIDATION_ERROR_UNEXPECTED_INVALID_INTERFACE_ID,
+                        error_message);
+  return false;
+}
+
+inline bool ValidateHandleOrInterfaceNonNullable(
     const Interface_Data& input,
     const char* error_message,
-    ValidationContext* validation_context);
-bool ValidateHandleOrInterfaceNonNullable(
+    ValidationContext* validation_context) {
+  if (IsHandleOrInterfaceValid(input))
+    return true;
+
+  ReportValidationError(validation_context,
+                        VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
+                        error_message);
+  return false;
+}
+
+inline bool ValidateHandleOrInterfaceNonNullable(
     const Handle_Data& input,
     const char* error_message,
-    ValidationContext* validation_context);
+    ValidationContext* validation_context) {
+  if (IsHandleOrInterfaceValid(input))
+    return true;
+
+  ReportValidationError(validation_context,
+                        VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
+                        error_message);
+  return false;
+}
+
+inline bool ValidateHandleOrInterface(const AssociatedInterface_Data& input,
+                                      ValidationContext* validation_context) {
+  if (!IsMasterInterfaceId(input.interface_id))
+    return true;
+
+  ReportValidationError(validation_context,
+                        VALIDATION_ERROR_ILLEGAL_INTERFACE_ID);
+  return false;
+}
+
+inline bool ValidateHandleOrInterface(
+    const AssociatedInterfaceRequest_Data& input,
+    ValidationContext* validation_context) {
+  if (!IsMasterInterfaceId(input.interface_id))
+    return true;
+
+  ReportValidationError(validation_context,
+                        VALIDATION_ERROR_ILLEGAL_INTERFACE_ID);
+  return false;
+}
+
+inline bool ValidateHandleOrInterface(const Interface_Data& input,
+                                      ValidationContext* validation_context) {
+  if (validation_context->ClaimHandle(input.handle))
+    return true;
+
+  ReportValidationError(validation_context, VALIDATION_ERROR_ILLEGAL_HANDLE);
+  return false;
+}
+
+inline bool ValidateHandleOrInterface(const Handle_Data& input,
+                                      ValidationContext* validation_context) {
+  if (validation_context->ClaimHandle(input))
+    return true;
+
+  ReportValidationError(validation_context, VALIDATION_ERROR_ILLEGAL_HANDLE);
+  return false;
+}
 
 template <typename T>
 bool ValidateContainer(const Pointer<T>& input,
                        ValidationContext* validation_context,
                        const ContainerValidateParams* validate_params) {
   return ValidatePointer(input, validation_context) &&
          T::Validate(input.Get(), validation_context, validate_params);
 }
 
 template <typename T>
 bool ValidateStruct(const Pointer<T>& input,
                     ValidationContext* validation_context) {
   return ValidatePointer(input, validation_context) &&
          T::Validate(input.Get(), validation_context);
 }
 
 template <typename T>
 bool ValidateInlinedUnion(const T& input,
                           ValidationContext* validation_context) {
   return T::Validate(&input, validation_context, true);
 }
 
 template <typename T>
 bool ValidateNonInlinedUnion(const Pointer<T>& input,
                              ValidationContext* validation_context) {
   return ValidatePointer(input, validation_context) &&
          T::Validate(input.Get(), validation_context, false);
 }
 
-bool ValidateHandleOrInterface(const AssociatedInterface_Data& input,
-                               ValidationContext* validation_context);
-bool ValidateHandleOrInterface(const AssociatedInterfaceRequest_Data& input,
-                               ValidationContext* validation_context);
-bool ValidateHandleOrInterface(const Interface_Data& input,
-                               ValidationContext* validation_context);
-bool ValidateHandleOrInterface(const Handle_Data& input,
-                               ValidationContext* validation_context);
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_VALIDATION_UTIL_H_