Turn //mojo/public/cpp/bindings and //mojo/public/cpp/system into components

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/bindings_export.h"
 #include "mojo/public/cpp/bindings/lib/bindings_internal.h"
 #include "mojo/public/cpp/bindings/lib/serialization_util.h"
 #include "mojo/public/cpp/bindings/lib/validate_params.h"
 #include "mojo/public/cpp/bindings/lib/validation_context.h"
 #include "mojo/public/cpp/bindings/lib/validation_errors.h"
 #include "mojo/public/cpp/bindings/message.h"
 
 namespace mojo {
 namespace internal {
 
@@ skipping 19 matching lines @@
   return result;
 }
 
 // Validates that |data| contains a valid struct header, in terms of alignment
 // and size (i.e., the |num_bytes| field of the header is sufficient for storing
 // the header itself). Besides, 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.
 // Note: Does not verify |version| or that |num_bytes| is correct for the
 // claimed version.
-bool ValidateStructHeaderAndClaimMemory(const void* data,
-                                        ValidationContext* validation_context);
+MOJO_CPP_BINDINGS_EXPORT bool ValidateStructHeaderAndClaimMemory(

[yzshen1, 2016/09/22 18:26:27]

I notice that some places put MOJO_CPP_BINDINGS_EXPORT at the beginning of a
function signature; while the others put it between the return type and the
function name (For example, ReportBadMessage in message.h). Please make them
consistent.

[dcheng, 2016/09/22 22:18:21]

I thought I fixed them all but I guessed I missed a couple. Done... I hope.

+    const void* data,
+    ValidationContext* validation_context);
 
 // Validates that |data| contains a valid union header, in terms of alignment
 // and size. It checks that the memory range [data, data + kUnionDataSize) is
 // not marked as occupied by other objects in |validation_context|. On success,
 // the memory range is marked as occupied.
-bool ValidateNonInlinedUnionHeaderAndClaimMemory(
+MOJO_CPP_BINDINGS_EXPORT bool ValidateNonInlinedUnionHeaderAndClaimMemory(
     const void* data,
     ValidationContext* validation_context);
 
 // Validates that the message is a request which doesn't expect a response.
-bool ValidateMessageIsRequestWithoutResponse(
+MOJO_CPP_BINDINGS_EXPORT bool ValidateMessageIsRequestWithoutResponse(
     const Message* message,
     ValidationContext* validation_context);
 
 // Validates that the message is a request expecting a response.
-bool ValidateMessageIsRequestExpectingResponse(
+MOJO_CPP_BINDINGS_EXPORT bool ValidateMessageIsRequestExpectingResponse(
     const Message* message,
     ValidationContext* validation_context);
 
 // Validates that the message is a response.
-bool ValidateMessageIsResponse(const Message* message,
-                               ValidationContext* validation_context);
+MOJO_CPP_BINDINGS_EXPORT bool ValidateMessageIsResponse(
+    const Message* message,
+    ValidationContext* validation_context);
 
 // 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 Validate.*NonNullable() functions validate that the given
 // |input| is not null/invalid.
@@ skipping 16 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);
+MOJO_CPP_BINDINGS_EXPORT bool IsHandleOrInterfaceValid(
+    const AssociatedInterface_Data& input);
+MOJO_CPP_BINDINGS_EXPORT bool IsHandleOrInterfaceValid(
+    const AssociatedInterfaceRequest_Data& input);
+MOJO_CPP_BINDINGS_EXPORT bool IsHandleOrInterfaceValid(
+    const Interface_Data& input);
+MOJO_CPP_BINDINGS_EXPORT bool IsHandleOrInterfaceValid(
+    const Handle_Data& input);
 
-bool ValidateHandleOrInterfaceNonNullable(
+MOJO_CPP_BINDINGS_EXPORT bool ValidateHandleOrInterfaceNonNullable(
     const AssociatedInterface_Data& input,
     const char* error_message,
     ValidationContext* validation_context);
-bool ValidateHandleOrInterfaceNonNullable(
+MOJO_CPP_BINDINGS_EXPORT bool ValidateHandleOrInterfaceNonNullable(
     const AssociatedInterfaceRequest_Data& input,
     const char* error_message,
     ValidationContext* validation_context);
-bool ValidateHandleOrInterfaceNonNullable(
+MOJO_CPP_BINDINGS_EXPORT bool ValidateHandleOrInterfaceNonNullable(
     const Interface_Data& input,
     const char* error_message,
     ValidationContext* validation_context);
-bool ValidateHandleOrInterfaceNonNullable(
+MOJO_CPP_BINDINGS_EXPORT bool ValidateHandleOrInterfaceNonNullable(
     const Handle_Data& input,
     const char* error_message,
     ValidationContext* validation_context);
 
 template <typename T>
 bool ValidateContainer(const Pointer<T>& input,
                        ValidationContext* validation_context,
                        const ContainerValidateParams* validate_params) {
   ValidationContext::ScopedDepthTracker depth_tracker(validation_context);
   if (validation_context->ExceedsMaxDepth()) {
@@ skipping 36 matching lines @@
   ValidationContext::ScopedDepthTracker depth_tracker(validation_context);
   if (validation_context->ExceedsMaxDepth()) {
     ReportValidationError(validation_context,
                           VALIDATION_ERROR_MAX_RECURSION_DEPTH);
     return false;
   }
   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);
+MOJO_CPP_BINDINGS_EXPORT bool ValidateHandleOrInterface(
+    const AssociatedInterface_Data& input,
+    ValidationContext* validation_context);
+MOJO_CPP_BINDINGS_EXPORT bool ValidateHandleOrInterface(
+    const AssociatedInterfaceRequest_Data& input,
+    ValidationContext* validation_context);
+MOJO_CPP_BINDINGS_EXPORT bool ValidateHandleOrInterface(
+    const Interface_Data& input,
+    ValidationContext* validation_context);
+MOJO_CPP_BINDINGS_EXPORT bool ValidateHandleOrInterface(
+    const Handle_Data& input,
+    ValidationContext* validation_context);
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_VALIDATION_UTIL_H_