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

mojo/public/cpp/bindings/message.h

 // Copyright 2014 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_MESSAGE_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_MESSAGE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
+#include "base/compiler_specific.h"
 #include "base/logging.h"
+#include "mojo/public/cpp/bindings/bindings_export.h"
 #include "mojo/public/cpp/bindings/lib/message_buffer.h"
 #include "mojo/public/cpp/bindings/lib/message_internal.h"
 #include "mojo/public/cpp/system/message.h"
 
 namespace mojo {
 
 using ReportBadMessageCallback = base::Callback<void(const std::string& error)>;
 
 // Message is a holder for the data and handles to be sent over a MessagePipe.
 // Message owns its data and handles, but a consumer of Message is free to
 // mutate the data and handles. The message's data is comprised of a header
 // followed by payload.
-class Message {
+class MOJO_CPP_BINDINGS_EXPORT Message {
  public:
   static const uint32_t kFlagExpectsResponse = 1 << 0;
   static const uint32_t kFlagIsResponse = 1 << 1;
   static const uint32_t kFlagIsSync = 1 << 2;
 
   Message();
   Message(Message&& other);
 
   ~Message();
 
@@ skipping 152 matching lines @@
   // |responder| and will delete it after calling |responder->Accept| or upon
   // its own destruction.
   //
   // TODO(yzshen): consider changing |responder| to
   // std::unique_ptr<MessageReceiver>.
   virtual bool AcceptWithResponder(Message* message,
                                    MessageReceiverWithStatus* responder)
       WARN_UNUSED_RESULT = 0;
 };
 
-class PassThroughFilter : public MessageReceiver {
+class MOJO_CPP_BINDINGS_EXPORT PassThroughFilter
+    : NON_EXPORTED_BASE(public MessageReceiver) {
  public:
   PassThroughFilter();
   ~PassThroughFilter() override;
 
   // MessageReceiver:
   bool Accept(Message* message) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PassThroughFilter);
 };
 
 namespace internal {
 class SyncMessageResponseSetup;
 }
 
 // An object which should be constructed on the stack immediately before making
 // a sync request for which the caller wishes to perform custom validation of
 // the response value(s). It is illegal to make more than one sync call during
 // the lifetime of the topmost SyncMessageResponseContext, but it is legal to
 // nest contexts to support reentrancy.
 //
 // Usage should look something like:
 //
 //     SyncMessageResponseContext response_context;
 //     foo_interface->SomeSyncCall(&response_value);
 //     if (response_value.IsBad())
 //       response_context.ReportBadMessage("Bad response_value!");
 //
-class SyncMessageResponseContext {
+class MOJO_CPP_BINDINGS_EXPORT SyncMessageResponseContext {
  public:
   SyncMessageResponseContext();
   ~SyncMessageResponseContext();
 
   static SyncMessageResponseContext* current();
 
   void ReportBadMessage(const std::string& error);
 
   const ReportBadMessageCallback& GetBadMessageCallback();
 
@@ skipping 14 matching lines @@
 // dispatched, otherwise returns an error code if something went wrong.
 //
 // NOTE: The message hasn't been validated and may be malformed!
 MojoResult ReadMessage(MessagePipeHandle handle, Message* message);
 
 // Reports the currently dispatching Message as bad. Note that this is only
 // legal to call from directly within the stack frame of a message dispatch. If
 // you need to do asynchronous work before you can determine the legitimacy of
 // a message, use TakeBadMessageCallback() and retain its result until you're
 // ready to invoke or discard it.
-void ReportBadMessage(const std::string& error);
+void MOJO_CPP_BINDINGS_EXPORT ReportBadMessage(const std::string& error);
 
 // Acquires a callback which may be run to report the currently dispatching
 // Message as bad. Note that this is only legal to call from directly within the
 // stack frame of a message dispatch, but the returned callback may be called
 // exactly once any time thereafter to report the message as bad. This may only
 // be called once per message.
-ReportBadMessageCallback GetBadMessageCallback();
+ReportBadMessageCallback MOJO_CPP_BINDINGS_EXPORT GetBadMessageCallback();
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_MESSAGE_H_