EDK: Remove MOJO_SYSTEM_IMPL_EXPORT, system_impl_export.h, etc.

mojo/edk/system/raw_channel.h

 // Copyright 2013 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_EDK_SYSTEM_RAW_CHANNEL_H_
 #define MOJO_EDK_SYSTEM_RAW_CHANNEL_H_
 
 #include <memory>
 #include <vector>
 
 #include "base/memory/weak_ptr.h"
 #include "mojo/edk/embedder/platform_handle_vector.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/system/message_in_transit_queue.h"
 #include "mojo/edk/system/mutex.h"
-#include "mojo/edk/system/system_impl_export.h"
 #include "mojo/edk/system/thread_annotations.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace base {
 class MessageLoopForIO;
 }
 
 namespace mojo {
 namespace system {
 
 // |RawChannel| is an interface and base class for objects that wrap an OS
 // "pipe". It presents the following interface to users:
 //  - Receives and dispatches messages on an I/O thread (running a
 //    |MessageLoopForIO|.
 //  - Provides a thread-safe way of writing messages (|WriteMessage()|);
 //    writing/queueing messages will not block and is atomic from the point of
 //    view of the caller. If necessary, messages are queued (to be written on
 //    the aforementioned thread).
 //
 // OS-specific implementation subclasses are to be instantiated using the
 // |Create()| static factory method.
 //
 // With the exception of |WriteMessage()| and |IsWriteBufferEmpty()|, this class
 // is thread-unsafe (and in general its methods should only be used on the I/O
 // thread, i.e., the thread on which |Init()| is called).
-class MOJO_SYSTEM_IMPL_EXPORT RawChannel {
+class RawChannel {
  public:
   // This object may be destroyed on any thread (if |Init()| was called, after
   // |Shutdown()| was called).
   virtual ~RawChannel();
 
   // The |Delegate| is only accessed on the same thread as the message loop
   // (passed in on creation).
-  class MOJO_SYSTEM_IMPL_EXPORT Delegate {
+  class Delegate {
    public:
     enum Error {
       // Failed read due to raw channel shutdown (e.g., on the other side).
       ERROR_READ_SHUTDOWN,
       // Failed read due to raw channel being broken (e.g., if the other side
       // died without shutting down).
       ERROR_READ_BROKEN,
       // Received a bad message.
       ERROR_READ_BAD_MESSAGE,
       // Unknown read error.
@@ skipping 58 matching lines @@
     IO_SUCCEEDED,
     // Failed due to a (probably) clean shutdown (e.g., of the other end).
     IO_FAILED_SHUTDOWN,
     // Failed due to the connection being broken (e.g., the other end dying).
     IO_FAILED_BROKEN,
     // Failed due to some other (unexpected) reason.
     IO_FAILED_UNKNOWN,
     IO_PENDING
   };
 
-  class MOJO_SYSTEM_IMPL_EXPORT ReadBuffer {
+  class ReadBuffer {
    public:
     ReadBuffer();
     ~ReadBuffer();
 
     void GetBuffer(char** addr, size_t* size);
 
    private:
     friend class RawChannel;
 
     // We store data from |[Schedule]Read()|s in |buffer_|. The start of
     // |buffer_| is always aligned with a message boundary (we will copy memory
     // to ensure this), but |buffer_| may be larger than the actual number of
     // bytes we have.
     std::vector<char> buffer_;
     size_t num_valid_bytes_;
 
     MOJO_DISALLOW_COPY_AND_ASSIGN(ReadBuffer);
   };
 
-  class MOJO_SYSTEM_IMPL_EXPORT WriteBuffer {
+  class WriteBuffer {
    public:
     struct Buffer {
       const char* addr;
       size_t size;
     };
 
     explicit WriteBuffer(size_t serialized_platform_handle_size);
     ~WriteBuffer();
 
     // Returns true if there are (more) platform handles to be sent (from the
@@ skipping 168 matching lines @@
   base::WeakPtrFactory<RawChannel> weak_ptr_factory_
       MOJO_GUARDED_BY(write_mutex_);
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(RawChannel);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_RAW_CHANNEL_H_