[NaCl SDK] Define pepper interface for nacl_mounts use macros.

BUG=none
R=noelallen@chromium.org
NOTRY=true


Review URL: https://chromiumcodereview.appspot.com/11627002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@173957 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 309 insertions, 472 deletions

diff --git a/native_client_sdk/src/libraries/nacl_mounts/library.dsc b/native_client_sdk/src/libraries/nacl_mounts/library.dsc
index b0de0e1..3568dde 100644
--- a/native_client_sdk/src/libraries/nacl_mounts/library.dsc
+++ b/native_client_sdk/src/libraries/nacl_mounts/library.dsc
@@ -5,6 +5,7 @@
   'TOOLS': ['newlib', 'glibc', 'win'],
   'SEARCH': [
     '.',
+    'pepper',
     '../utils'
   ],
   'TARGETS': [
@@ -60,6 +61,14 @@
     },
     {
       'FILES': [
+        "all_interfaces.h",
+        "define_empty_macros.h",
+        "undef_macros.h",
+      ],
+      'DEST': 'include/nacl_mounts/pepper',
+    },
+    {
+      'FILES': [
         "auto_lock.h",
         "macros.h",
         "ref_object.h"
diff --git a/native_client_sdk/src/libraries/nacl_mounts/pepper/all_interfaces.h b/native_client_sdk/src/libraries/nacl_mounts/pepper/all_interfaces.h
new file mode 100644
index 0000000..1dd46b1
--- /dev/null
+++ b/native_client_sdk/src/libraries/nacl_mounts/pepper/all_interfaces.h
@@ -0,0 +1,71 @@
+/* Copyright (c) 2012 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.
+ */
+
+/* Given an interface like this:
+ *
+ *   struct PPB_Frob {
+ *     void (*Flange)(int32_t param1, char* param2);
+ *     int32_t (*Shlep)(PP_CompletionCallback);
+ *   };
+ *
+ * Write a set of macros like this:
+ *
+ *   BEGIN_INTERFACE(FrobInterface, PPB_Frob, PPB_FROB_INTERFACE)
+ *     METHOD2(FrobInterface, void, Flange, int32_t, char*)
+ *     METHOD1(FrobInterface, int32_t, Shlep, PP_CompletionCallback)
+ *   END_INTERFACE(FrobInterface, PPB_Frob)
+ */
+
+BEGIN_INTERFACE(ConsoleInterface, PPB_Console, PPB_CONSOLE_INTERFACE)
+  METHOD3(ConsoleInterface, void, Log, PP_Instance, PP_LogLevel, struct PP_Var)
+END_INTERFACE(ConsoleInterface, PPB_Console)
+
+BEGIN_INTERFACE(DirectoryReaderInterface, PPB_DirectoryReader_Dev,
+                PPB_DIRECTORYREADER_DEV_INTERFACE)
+  METHOD1(DirectoryReaderInterface, PP_Resource, Create, PP_Resource)
+  METHOD3(DirectoryReaderInterface, int32_t, GetNextEntry, PP_Resource,
+          PP_DirectoryEntry_Dev*, PP_CompletionCallback)
+END_INTERFACE(DirectoryReaderInterface, PPB_DirectoryReader_Dev)
+
+BEGIN_INTERFACE(FileIoInterface, PPB_FileIO, PPB_FILEIO_INTERFACE)
+  METHOD1(FileIoInterface, void, Close, PP_Resource)
+  METHOD1(FileIoInterface, PP_Resource, Create, PP_Resource)
+  METHOD2(FileIoInterface, int32_t, Flush, PP_Resource,
+          PP_CompletionCallback)
+  METHOD4(FileIoInterface, int32_t, Open, PP_Resource, PP_Resource, int32_t,
+          PP_CompletionCallback)
+  METHOD3(FileIoInterface, int32_t, Query, PP_Resource, PP_FileInfo*,
+          PP_CompletionCallback)
+  METHOD5(FileIoInterface, int32_t, Read, PP_Resource, int64_t, char*,
+          int32_t, PP_CompletionCallback)
+  METHOD3(FileIoInterface, int32_t, SetLength, PP_Resource, int64_t,
+          PP_CompletionCallback)
+  METHOD5(FileIoInterface, int32_t, Write, PP_Resource, int64_t,
+          const char*, int32_t, PP_CompletionCallback)
+END_INTERFACE(FileIoInterface, PPB_FileIO)
+
+BEGIN_INTERFACE(FileRefInterface, PPB_FileRef, PPB_FILEREF_INTERFACE)
+  METHOD2(FileRefInterface, PP_Resource, Create, PP_Resource, const char*)
+  METHOD2(FileRefInterface, int32_t, Delete, PP_Resource, PP_CompletionCallback)
+  METHOD1(FileRefInterface, PP_Var, GetName, PP_Resource)
+  METHOD3(FileRefInterface, int32_t, MakeDirectory, PP_Resource, PP_Bool,
+          PP_CompletionCallback)
+END_INTERFACE(FileRefInterface, PPB_FileRef)
+
+BEGIN_INTERFACE(FileSystemInterface, PPB_FileSystem, PPB_FILESYSTEM_INTERFACE)
+  METHOD2(FileSystemInterface, PP_Resource, Create, PP_Instance,
+          PP_FileSystemType)
+  METHOD3(FileSystemInterface, int32_t, Open, PP_Resource, int64_t,
+          PP_CompletionCallback)
+END_INTERFACE(FileSystemInterface, PPB_FileSystem)
+
+BEGIN_INTERFACE(MessagingInterface, PPB_Messaging, PPB_MESSAGING_INTERFACE)
+  METHOD2(MessagingInterface, void, PostMessage, PP_Instance, struct PP_Var)
+END_INTERFACE(MessagingInterface, PPB_Messaging)
+
+BEGIN_INTERFACE(VarInterface, PPB_Var, PPB_VAR_INTERFACE)
+  METHOD2(VarInterface, struct PP_Var, VarFromUtf8, const char *, uint32_t)
+  METHOD2(VarInterface, const char*, VarToUtf8, PP_Var, uint32_t*)
+END_INTERFACE(VarInterface, PPB_Var)
diff --git a/native_client_sdk/src/libraries/nacl_mounts/pepper/define_empty_macros.h b/native_client_sdk/src/libraries/nacl_mounts/pepper/define_empty_macros.h
new file mode 100644
index 0000000..c93b6d8
--- /dev/null
+++ b/native_client_sdk/src/libraries/nacl_mounts/pepper/define_empty_macros.h
@@ -0,0 +1,13 @@
+/* Copyright (c) 2012 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.
+ */
+
+#define BEGIN_INTERFACE(BaseClass, PPInterface, InterfaceString)
+#define END_INTERFACE(BaseClass, PPInterface)
+#define METHOD1(Class, ReturnType, MethodName, Type0)
+#define METHOD2(Class, ReturnType, MethodName, Type0, Type1)
+#define METHOD3(Class, ReturnType, MethodName, Type0, Type1, Type2)
+#define METHOD4(Class, ReturnType, MethodName, Type0, Type1, Type2, Type3)
+#define METHOD5(Class, ReturnType, MethodName, Type0, Type1, Type2, Type3, \
+                Type4)
diff --git a/native_client_sdk/src/libraries/nacl_mounts/pepper/undef_macros.h b/native_client_sdk/src/libraries/nacl_mounts/pepper/undef_macros.h
new file mode 100644
index 0000000..1b75b46
--- /dev/null
+++ b/native_client_sdk/src/libraries/nacl_mounts/pepper/undef_macros.h
@@ -0,0 +1,12 @@
+/* Copyright (c) 2012 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.
+ */
+
+#undef BEGIN_INTERFACE
+#undef END_INTERFACE
+#undef METHOD1
+#undef METHOD2
+#undef METHOD3
+#undef METHOD4
+#undef METHOD5
diff --git a/native_client_sdk/src/libraries/nacl_mounts/pepper_interface.h b/native_client_sdk/src/libraries/nacl_mounts/pepper_interface.h
index fd7f1f0..399c805 100644
--- a/native_client_sdk/src/libraries/nacl_mounts/pepper_interface.h
+++ b/native_client_sdk/src/libraries/nacl_mounts/pepper_interface.h
@@ -12,17 +12,30 @@
 #include <ppapi/c/pp_resource.h>
 #include <ppapi/c/pp_var.h>
 #include <ppapi/c/ppb_console.h>
+#include <ppapi/c/ppb_file_io.h>
+#include <ppapi/c/ppb_file_ref.h>
+#include <ppapi/c/ppb_file_system.h>
 #include <ppapi/c/ppb_messaging.h>
+#include <ppapi/c/ppb_messaging.h>
+#include <ppapi/c/ppb_var.h>
 
 #include <utils/macros.h>
 
-class ConsoleInterface;
-class DirectoryReaderInterface;
-class FileIoInterface;
-class FileRefInterface;
-class FileSystemInterface;
-class MessagingInterface;
-class VarInterface;
+// Note: To add a new interface:
+//
+// 1. Using one of the other interfaces as a template, add your interface to
+//    all_interfaces.h.
+// 2. Add the necessary pepper header to the top of this file.
+// 3. Compile and cross your fingers!
+
+
+// Forward declare interface classes.
+#include "nacl_mounts/pepper/define_empty_macros.h"
+#undef BEGIN_INTERFACE
+#define BEGIN_INTERFACE(BaseClass, PPInterface, InterfaceString) \
+    class BaseClass;
+#include "nacl_mounts/pepper/all_interfaces.h"
+#include "nacl_mounts/pepper/undef_macros.h"
 
 int PPErrorToErrno(int32_t err);
 
@@ -32,76 +45,36 @@ class PepperInterface {
   virtual PP_Instance GetInstance() = 0;
   virtual void AddRefResource(PP_Resource) = 0;
   virtual void ReleaseResource(PP_Resource) = 0;
-  virtual ConsoleInterface* GetConsoleInterface() = 0;
-  virtual FileSystemInterface* GetFileSystemInterface() = 0;
-  virtual FileRefInterface* GetFileRefInterface() = 0;
-  virtual FileIoInterface* GetFileIoInterface() = 0;
-  virtual DirectoryReaderInterface* GetDirectoryReaderInterface() = 0;
-  virtual MessagingInterface* GetMessagingInterface() = 0;
-  virtual VarInterface* GetVarInterface() = 0;
-};
-
-class ConsoleInterface {
- public:
-  virtual ~ConsoleInterface() {}
-  virtual void Log(PP_Instance, PP_LogLevel, struct PP_Var) = 0;
-};
-
-class FileSystemInterface {
- public:
-  virtual ~FileSystemInterface() {}
-  virtual PP_Resource Create(PP_Instance, PP_FileSystemType) = 0;
-  virtual int32_t Open(PP_Resource, int64_t, PP_CompletionCallback) = 0;
-};
-
-class FileRefInterface {
- public:
-  virtual ~FileRefInterface() {}
-  virtual PP_Resource Create(PP_Resource, const char*) = 0;
-  virtual int32_t Delete(PP_Resource, PP_CompletionCallback) = 0;
-  virtual PP_Var GetName(PP_Resource) = 0;
-  virtual int32_t MakeDirectory(PP_Resource, PP_Bool,
-      PP_CompletionCallback) = 0;
-};
-
-class FileIoInterface {
- public:
-  virtual ~FileIoInterface() {}
-  virtual void Close(PP_Resource) = 0;
-  virtual PP_Resource Create(PP_Instance) = 0;
-  virtual int32_t Flush(PP_Resource, PP_CompletionCallback) = 0;
-  virtual int32_t Open(PP_Resource, PP_Resource, int32_t,
-      PP_CompletionCallback) = 0;
-  virtual int32_t Query(PP_Resource, PP_FileInfo*,
-      PP_CompletionCallback) = 0;
-  virtual int32_t Read(PP_Resource, int64_t, char*, int32_t,
-      PP_CompletionCallback) = 0;
-  virtual int32_t SetLength(PP_Resource, int64_t,
-      PP_CompletionCallback) = 0;
-  virtual int32_t Write(PP_Resource, int64_t, const char*, int32_t,
-      PP_CompletionCallback) = 0;
-};
 
-class DirectoryReaderInterface {
- public:
-  virtual ~DirectoryReaderInterface() {}
-  virtual PP_Resource Create(PP_Resource) = 0;
-  virtual int32_t GetNextEntry(PP_Resource, PP_DirectoryEntry_Dev*,
-      PP_CompletionCallback) = 0;
+// Interface getters.
+#include "nacl_mounts/pepper/define_empty_macros.h"
+#undef BEGIN_INTERFACE
+#define BEGIN_INTERFACE(BaseClass, PPInterface, InterfaceString) \
+    virtual BaseClass* Get##BaseClass() = 0;
+#include "nacl_mounts/pepper/all_interfaces.h"
+#include "nacl_mounts/pepper/undef_macros.h"
 };
 
-class MessagingInterface {
- public:
-  virtual ~MessagingInterface() {}
-  virtual void PostMessage(PP_Instance, struct PP_Var ) = 0;
-};
-
-class VarInterface {
- public:
-  virtual ~VarInterface() {}
-  virtual struct PP_Var VarFromUtf8(const char*, uint32_t) = 0;
-  virtual const char* VarToUtf8(PP_Var, uint32_t*) = 0;
-};
+// Interface class definitions.
+#define BEGIN_INTERFACE(BaseClass, PPInterface, InterfaceString) \
+    class BaseClass { \
+     public: \
+      virtual ~BaseClass() {}
+#define END_INTERFACE(BaseClass, PPInterface) \
+    };
+#define METHOD1(Class, ReturnType, MethodName, Type0) \
+    virtual ReturnType MethodName(Type0) = 0;
+#define METHOD2(Class, ReturnType, MethodName, Type0, Type1) \
+    virtual ReturnType MethodName(Type0, Type1) = 0;
+#define METHOD3(Class, ReturnType, MethodName, Type0, Type1, Type2) \
+    virtual ReturnType MethodName(Type0, Type1, Type2) = 0;
+#define METHOD4(Class, ReturnType, MethodName, Type0, Type1, Type2, Type3) \
+    virtual ReturnType MethodName(Type0, Type1, Type2, Type3) = 0;
+#define METHOD5(Class, ReturnType, MethodName, Type0, Type1, Type2, Type3, \
+                Type4) \
+    virtual ReturnType MethodName(Type0, Type1, Type2, Type3, Type4) = 0;
+#include "nacl_mounts/pepper/all_interfaces.h"
+#include "nacl_mounts/pepper/undef_macros.h"
 
 
 class ScopedResource {
diff --git a/native_client_sdk/src/libraries/nacl_mounts/real_pepper_interface.cc b/native_client_sdk/src/libraries/nacl_mounts/real_pepper_interface.cc
index 86c5727..22d9ea8 100644
--- a/native_client_sdk/src/libraries/nacl_mounts/real_pepper_interface.cc
+++ b/native_client_sdk/src/libraries/nacl_mounts/real_pepper_interface.cc
@@ -8,177 +8,63 @@
 #include <stdio.h>
 
 #include <ppapi/c/pp_errors.h>
-#include <ppapi/c/ppb_console.h>
-#include <ppapi/c/ppb_file_io.h>
-#include <ppapi/c/ppb_file_ref.h>
-#include <ppapi/c/ppb_file_system.h>
-#include <ppapi/c/ppb_messaging.h>
-#include <ppapi/c/ppb_var.h>
 
-#define DEFINE_CONSTRUCTOR(Class, Interface) \
-    Class::Class(const Interface* interface) : interface_(interface) {}
 
-#define DEFINE_METHOD1(Class, ReturnType, MethodName, Type0) \
-    ReturnType Class::MethodName(Type0 arg0) { \
+#include "nacl_mounts/pepper/undef_macros.h"
+#define BEGIN_INTERFACE(BaseClass, PPInterface, InterfaceString) \
+    class Real##BaseClass : public BaseClass { \
+     public: \
+      explicit Real##BaseClass(const PPInterface* interface);
+#define END_INTERFACE(BaseClass, PPInterface) \
+     private: \
+      const PPInterface* interface_; \
+    };
+#define METHOD1(Class, ReturnType, MethodName, Type0) \
+    virtual ReturnType MethodName(Type0);
+#define METHOD2(Class, ReturnType, MethodName, Type0, Type1) \
+    virtual ReturnType MethodName(Type0, Type1);
+#define METHOD3(Class, ReturnType, MethodName, Type0, Type1, Type2) \
+    virtual ReturnType MethodName(Type0, Type1, Type2);
+#define METHOD4(Class, ReturnType, MethodName, Type0, Type1, Type2, Type3) \
+    virtual ReturnType MethodName(Type0, Type1, Type2, Type3);
+#define METHOD5(Class, ReturnType, MethodName, Type0, Type1, Type2, Type3, \
+                Type4) \
+    virtual ReturnType MethodName(Type0, Type1, Type2, Type3, Type4);
+#include "nacl_mounts/pepper/all_interfaces.h"
+
+
+#include "nacl_mounts/pepper/undef_macros.h"
+#define BEGIN_INTERFACE(BaseClass, PPInterface, InterfaceString) \
+    Real##BaseClass::Real##BaseClass(const PPInterface* interface) \
+        : interface_(interface) {}
+
+#define END_INTERFACE(BaseClass, PPInterface)
+
+#define METHOD1(BaseClass, ReturnType, MethodName, Type0) \
+    ReturnType Real##BaseClass::MethodName(Type0 arg0) { \
       return interface_->MethodName(arg0); \
     }
-
-#define DEFINE_METHOD2(Class, ReturnType, MethodName, Type0, Type1) \
-    ReturnType Class::MethodName(Type0 arg0, Type1 arg1) { \
+#define METHOD2(BaseClass, ReturnType, MethodName, Type0, Type1) \
+    ReturnType Real##BaseClass::MethodName(Type0 arg0, Type1 arg1) { \
       return interface_->MethodName(arg0, arg1); \
     }
-
-#define DEFINE_METHOD3(Class, ReturnType, MethodName, Type0, Type1, Type2) \
-    ReturnType Class::MethodName(Type0 arg0, Type1 arg1, Type2 arg2) { \
+#define METHOD3(BaseClass, ReturnType, MethodName, Type0, Type1, Type2) \
+    ReturnType Real##BaseClass::MethodName(Type0 arg0, Type1 arg1, \
+                                           Type2 arg2) { \
       return interface_->MethodName(arg0, arg1, arg2); \
     }
-
-#define DEFINE_METHOD4(Class, ReturnType, MethodName, Type0, Type1, Type2, \
-                       Type3) \
-    ReturnType Class::MethodName(Type0 arg0, Type1 arg1, Type2 arg2, \
-                                 Type3 arg3) { \
+#define METHOD4(BaseClass, ReturnType, MethodName, Type0, Type1, Type2, Type3) \
+    ReturnType Real##BaseClass::MethodName(Type0 arg0, Type1 arg1, Type2 arg2, \
+                                           Type3 arg3) { \
       return interface_->MethodName(arg0, arg1, arg2, arg3); \
     }
-
-#define DEFINE_METHOD5(Class, ReturnType, MethodName, Type0, Type1, Type2, \
-                       Type3, Type4) \
-    ReturnType Class::MethodName(Type0 arg0, Type1 arg1, Type2 arg2, \
-                                 Type3 arg3, Type4 arg4) { \
+#define METHOD5(BaseClass, ReturnType, MethodName, Type0, Type1, Type2, Type3, \
+                Type4) \
+    ReturnType Real##BaseClass::MethodName(Type0 arg0, Type1 arg1, Type2 arg2, \
+                                           Type3 arg3, Type4 arg4) { \
       return interface_->MethodName(arg0, arg1, arg2, arg3, arg4); \
     }
-
-
-class RealFileSystemInterface : public FileSystemInterface {
- public:
-  explicit RealFileSystemInterface(const PPB_FileSystem* filesystem_interface);
-  virtual PP_Resource Create(PP_Instance, PP_FileSystemType);
-  virtual int32_t Open(PP_Resource, int64_t, PP_CompletionCallback);
-
- private:
-  const PPB_FileSystem* interface_;
-};
-DEFINE_CONSTRUCTOR(RealFileSystemInterface, PPB_FileSystem)
-DEFINE_METHOD2(RealFileSystemInterface, PP_Resource, Create, PP_Instance,
-    PP_FileSystemType)
-DEFINE_METHOD3(RealFileSystemInterface, int32_t, Open, PP_Resource, int64_t,
-    PP_CompletionCallback)
-
-
-class RealConsoleInterface : public ConsoleInterface {
- public:
-  explicit RealConsoleInterface(const PPB_Console* console_interface);
-  virtual void Log(PP_Instance, PP_LogLevel, struct PP_Var);
- private:
-  const PPB_Console* interface_;
-};
-DEFINE_CONSTRUCTOR(RealConsoleInterface, PPB_Console)
-DEFINE_METHOD3(RealConsoleInterface, void, Log, PP_Instance, PP_LogLevel,
-    struct PP_Var);
-
-
-class RealFileRefInterface : public FileRefInterface {
- public:
-  explicit RealFileRefInterface(const PPB_FileRef* fileref_interface);
-
-  virtual PP_Resource Create(PP_Resource, const char*);
-  virtual int32_t Delete(PP_Resource, PP_CompletionCallback);
-  virtual PP_Var GetName(PP_Resource);
-  virtual int32_t MakeDirectory(PP_Resource, PP_Bool,
-      PP_CompletionCallback);
-
- private:
-  const PPB_FileRef* interface_;
-};
-DEFINE_CONSTRUCTOR(RealFileRefInterface, PPB_FileRef)
-DEFINE_METHOD2(RealFileRefInterface, PP_Resource, Create, PP_Resource,
-    const char*)
-DEFINE_METHOD2(RealFileRefInterface, int32_t, Delete, PP_Resource,
-    PP_CompletionCallback)
-DEFINE_METHOD1(RealFileRefInterface, PP_Var, GetName, PP_Resource)
-DEFINE_METHOD3(RealFileRefInterface, int32_t, MakeDirectory, PP_Resource,
-    PP_Bool, PP_CompletionCallback);
-
-
-class RealFileIoInterface : public FileIoInterface {
- public:
-  explicit RealFileIoInterface(const PPB_FileIO* fileio_interface);
-
-  virtual void Close(PP_Resource);
-  virtual PP_Resource Create(PP_Instance);
-  virtual int32_t Flush(PP_Resource, PP_CompletionCallback);
-  virtual int32_t Open(PP_Resource, PP_Resource, int32_t,
-      PP_CompletionCallback);
-  virtual int32_t Query(PP_Resource, PP_FileInfo*, PP_CompletionCallback);
-  virtual int32_t Read(PP_Resource, int64_t, char*, int32_t,
-      PP_CompletionCallback);
-  virtual int32_t SetLength(PP_Resource, int64_t, PP_CompletionCallback);
-  virtual int32_t Write(PP_Resource, int64_t, const char*, int32_t,
-      PP_CompletionCallback);
-
- private:
-  const PPB_FileIO* interface_;
-};
-DEFINE_CONSTRUCTOR(RealFileIoInterface, PPB_FileIO)
-DEFINE_METHOD1(RealFileIoInterface, void, Close, PP_Resource)
-DEFINE_METHOD1(RealFileIoInterface, PP_Resource, Create, PP_Resource)
-DEFINE_METHOD2(RealFileIoInterface, int32_t, Flush, PP_Resource,
-    PP_CompletionCallback)
-DEFINE_METHOD4(RealFileIoInterface, int32_t, Open, PP_Resource, PP_Resource,
-    int32_t, PP_CompletionCallback);
-DEFINE_METHOD3(RealFileIoInterface, int32_t, Query, PP_Resource, PP_FileInfo*,
-    PP_CompletionCallback);
-DEFINE_METHOD5(RealFileIoInterface, int32_t, Read, PP_Resource, int64_t, char*,
-    int32_t, PP_CompletionCallback);
-DEFINE_METHOD3(RealFileIoInterface, int32_t, SetLength, PP_Resource, int64_t,
-    PP_CompletionCallback);
-DEFINE_METHOD5(RealFileIoInterface, int32_t, Write, PP_Resource, int64_t,
-    const char*, int32_t, PP_CompletionCallback);
-
-
-class RealDirectoryReaderInterface : public DirectoryReaderInterface {
- public:
-  explicit RealDirectoryReaderInterface(
-      const PPB_DirectoryReader_Dev* directory_reader_interface);
-
-  virtual PP_Resource Create(PP_Resource);
-  virtual int32_t GetNextEntry(PP_Resource, PP_DirectoryEntry_Dev*,
-      PP_CompletionCallback);
-
- private:
-  const PPB_DirectoryReader_Dev* interface_;
-};
-DEFINE_CONSTRUCTOR(RealDirectoryReaderInterface, PPB_DirectoryReader_Dev)
-DEFINE_METHOD1(RealDirectoryReaderInterface, PP_Resource, Create, PP_Resource)
-DEFINE_METHOD3(RealDirectoryReaderInterface, int32_t, GetNextEntry, PP_Resource,
-    PP_DirectoryEntry_Dev*, PP_CompletionCallback)
-
-class RealVarInterface : public VarInterface {
- public:
-  explicit RealVarInterface(const PPB_Var* var_interface);
-
-  virtual struct PP_Var VarFromUtf8(const char *, uint32_t);
-  virtual const char* VarToUtf8(PP_Var, uint32_t*);
-
- private:
-  const PPB_Var* interface_;
-};
-DEFINE_CONSTRUCTOR(RealVarInterface, PPB_Var)
-DEFINE_METHOD2(RealVarInterface, struct PP_Var, VarFromUtf8, const char *,
-    uint32_t)
-DEFINE_METHOD2(RealVarInterface, const char*, VarToUtf8, PP_Var, uint32_t*)
-
-class RealMessagingInterface : public MessagingInterface {
- public:
-  explicit RealMessagingInterface(const PPB_Messaging* messaging_interface);
-
-  virtual void PostMessage(PP_Instance, struct PP_Var);
-
-private:
-  const PPB_Messaging* interface_;
-};
-DEFINE_CONSTRUCTOR(RealMessagingInterface, PPB_Messaging);
-DEFINE_METHOD2(RealMessagingInterface, void, PostMessage, PP_Instance,
-    struct PP_Var);
+#include "nacl_mounts/pepper/all_interfaces.h"
 
 
 RealPepperInterface::RealPepperInterface(PP_Instance instance,
@@ -186,6 +72,7 @@ RealPepperInterface::RealPepperInterface(PP_Instance instance,
     : instance_(instance),
       core_interface_(NULL),
       message_loop_interface_(NULL) {
+
   core_interface_ = static_cast<const PPB_Core*>(
       get_browser_interface(PPB_CORE_INTERFACE));
   message_loop_interface_ = static_cast<const PPB_MessageLoop*>(
@@ -193,25 +80,14 @@ RealPepperInterface::RealPepperInterface(PP_Instance instance,
   assert(core_interface_);
   assert(message_loop_interface_);
 
-  console_interface_ = new RealConsoleInterface(
-      static_cast<const PPB_Console*>(get_browser_interface(
-          PPB_CONSOLE_INTERFACE)));
-  directory_reader_interface_ = new RealDirectoryReaderInterface(
-      static_cast<const PPB_DirectoryReader_Dev*>(get_browser_interface(
-          PPB_DIRECTORYREADER_DEV_INTERFACE)));
-  fileio_interface_ = new RealFileIoInterface(static_cast<const PPB_FileIO*>(
-      get_browser_interface(PPB_FILEIO_INTERFACE)));
-  fileref_interface_ = new RealFileRefInterface(static_cast<const PPB_FileRef*>(
-      get_browser_interface(PPB_FILEREF_INTERFACE)));
-  filesystem_interface_ = new RealFileSystemInterface(
-      static_cast<const PPB_FileSystem*>(get_browser_interface(
-          PPB_FILESYSTEM_INTERFACE)));
-  messaging_interface_ = new RealMessagingInterface(
-      static_cast<const PPB_Messaging*>(get_browser_interface(
-          PPB_MESSAGING_INTERFACE)));
-  var_interface_= new RealVarInterface(
-      static_cast<const PPB_Var*>(get_browser_interface(
-          PPB_VAR_INTERFACE)));
+#include "nacl_mounts/pepper/undef_macros.h"
+#include "nacl_mounts/pepper/define_empty_macros.h"
+#undef BEGIN_INTERFACE
+#define BEGIN_INTERFACE(BaseClass, PPInterface, InterfaceString) \
+    BaseClass##interface_ = new Real##BaseClass( \
+        static_cast<const PPInterface*>( \
+            get_browser_interface(InterfaceString)));
+#include "nacl_mounts/pepper/all_interfaces.h"
 }
 
 PP_Instance RealPepperInterface::GetInstance() {
@@ -228,33 +104,16 @@ void RealPepperInterface::ReleaseResource(PP_Resource resource) {
     core_interface_->ReleaseResource(resource);
 }
 
-ConsoleInterface* RealPepperInterface::GetConsoleInterface() {
-  return console_interface_;
-}
-
-FileSystemInterface* RealPepperInterface::GetFileSystemInterface() {
-  return filesystem_interface_;
-}
-
-FileRefInterface* RealPepperInterface::GetFileRefInterface() {
-  return fileref_interface_;
-}
-
-FileIoInterface* RealPepperInterface::GetFileIoInterface() {
-  return fileio_interface_;
-}
-
-DirectoryReaderInterface* RealPepperInterface::GetDirectoryReaderInterface() {
-  return directory_reader_interface_;
-}
-
-MessagingInterface* RealPepperInterface::GetMessagingInterface() {
-  return messaging_interface_;
-}
+// Define getter function.
+#include "nacl_mounts/pepper/undef_macros.h"
+#include "nacl_mounts/pepper/define_empty_macros.h"
+#undef BEGIN_INTERFACE
+#define BEGIN_INTERFACE(BaseClass, PPInterface, InterfaceString) \
+    BaseClass* RealPepperInterface::Get##BaseClass() { \
+      return BaseClass##interface_; \
+    }
+#include "nacl_mounts/pepper/all_interfaces.h"
 
-VarInterface* RealPepperInterface::GetVarInterface() {
-  return var_interface_;
-}
 
 int32_t RealPepperInterface::InitializeMessageLoop() {
   int32_t result;
diff --git a/native_client_sdk/src/libraries/nacl_mounts/real_pepper_interface.h b/native_client_sdk/src/libraries/nacl_mounts/real_pepper_interface.h
index 8e6e8a1..e51dff3 100644
--- a/native_client_sdk/src/libraries/nacl_mounts/real_pepper_interface.h
+++ b/native_client_sdk/src/libraries/nacl_mounts/real_pepper_interface.h
@@ -7,19 +7,16 @@
 
 #include <ppapi/c/ppb.h>
 #include <ppapi/c/ppb_core.h>
-#include <ppapi/c/ppb_console.h>
 #include <ppapi/c/ppb_message_loop.h>
-#include <ppapi/c/ppb_messaging.h>
-#include <ppapi/c/ppb_var.h>
 #include "pepper_interface.h"
 
-class RealConsoleInterface;
-class RealDirectoryReaderInterface;
-class RealFileIoInterface;
-class RealFileRefInterface;
-class RealFileSystemInterface;
-class RealMessagingInterface;
-class RealVarInterface;
+// Forward declare interface classes.
+#include "nacl_mounts/pepper/define_empty_macros.h"
+#undef BEGIN_INTERFACE
+#define BEGIN_INTERFACE(BaseClass, PPInterface, InterfaceString) \
+    class Real##BaseClass;
+#include "nacl_mounts/pepper/all_interfaces.h"
+#include "nacl_mounts/pepper/undef_macros.h"
 
 class RealPepperInterface : public PepperInterface {
  public:
@@ -29,13 +26,14 @@ class RealPepperInterface : public PepperInterface {
   virtual PP_Instance GetInstance();
   virtual void AddRefResource(PP_Resource);
   virtual void ReleaseResource(PP_Resource);
-  virtual ConsoleInterface* GetConsoleInterface();
-  virtual FileSystemInterface* GetFileSystemInterface();
-  virtual FileRefInterface* GetFileRefInterface();
-  virtual FileIoInterface* GetFileIoInterface();
-  virtual DirectoryReaderInterface* GetDirectoryReaderInterface();
-  virtual MessagingInterface* GetMessagingInterface();
-  virtual VarInterface* GetVarInterface();
+
+// Interface getters.
+#include "nacl_mounts/pepper/define_empty_macros.h"
+#undef BEGIN_INTERFACE
+#define BEGIN_INTERFACE(BaseClass, PPInterface, InterfaceString) \
+    virtual BaseClass* Get##BaseClass();
+#include "nacl_mounts/pepper/all_interfaces.h"
+#include "nacl_mounts/pepper/undef_macros.h"
 
   int32_t InitializeMessageLoop();
 
@@ -43,13 +41,14 @@ class RealPepperInterface : public PepperInterface {
   PP_Instance instance_;
   const PPB_Core* core_interface_;
   const PPB_MessageLoop* message_loop_interface_;
-  RealConsoleInterface* console_interface_;
-  RealDirectoryReaderInterface* directory_reader_interface_;
-  RealFileIoInterface* fileio_interface_;
-  RealFileRefInterface* fileref_interface_;
-  RealFileSystemInterface* filesystem_interface_;
-  RealMessagingInterface* messaging_interface_;
-  RealVarInterface* var_interface_;
+
+// Interface pointers.
+#include "nacl_mounts/pepper/define_empty_macros.h"
+#undef BEGIN_INTERFACE
+#define BEGIN_INTERFACE(BaseClass, PPInterface, InterfaceString) \
+    Real##BaseClass* BaseClass##interface_;
+#include "nacl_mounts/pepper/all_interfaces.h"
+#include "nacl_mounts/pepper/undef_macros.h"
 };
 
 #endif  // LIBRARIES_NACL_MOUNTS_REAL_PEPPER_INTERFACE_H_
diff --git a/native_client_sdk/src/libraries/nacl_mounts_test/pepper_interface_mock.cc b/native_client_sdk/src/libraries/nacl_mounts_test/pepper_interface_mock.cc
index 1f96630..ad0af97 100644
--- a/native_client_sdk/src/libraries/nacl_mounts_test/pepper_interface_mock.cc
+++ b/native_client_sdk/src/libraries/nacl_mounts_test/pepper_interface_mock.cc
@@ -7,96 +7,45 @@
 
 PepperInterfaceMock::PepperInterfaceMock(PP_Instance instance)
     : instance_(instance),
-      console_interface_(new ConsoleInterfaceMock),
-      filesystem_interface_(new FileSystemInterfaceMock),
-      fileref_interface_(new FileRefInterfaceMock),
-      fileio_interface_(new FileIoInterfaceMock),
-      directory_reader_interface_(new DirectoryReaderInterfaceMock),
-      messaging_interface_(new MessagingInterfaceMock),
-      var_interface_(new VarInterfaceMock) {
-}
-
-PepperInterfaceMock::~PepperInterfaceMock() {
-  delete console_interface_;
-  delete filesystem_interface_;
-  delete fileref_interface_;
-  delete fileio_interface_;
-  delete directory_reader_interface_;
-  delete messaging_interface_;
-  delete var_interface_;
-}
-
-PP_Instance PepperInterfaceMock::GetInstance() {
-  return instance_;
-}
-
-ConsoleInterfaceMock* PepperInterfaceMock::GetConsoleInterface() {
-  return console_interface_;
-}
-
-FileSystemInterfaceMock* PepperInterfaceMock::GetFileSystemInterface() {
-  return filesystem_interface_;
-}
-
-FileRefInterfaceMock* PepperInterfaceMock::GetFileRefInterface() {
-  return fileref_interface_;
-}
 
-FileIoInterfaceMock* PepperInterfaceMock::GetFileIoInterface() {
-  return fileio_interface_;
-}
-
-DirectoryReaderInterfaceMock*
-PepperInterfaceMock::GetDirectoryReaderInterface() {
-  return directory_reader_interface_;
-}
+    // Initialize interfaces.
+#include "nacl_mounts/pepper/define_empty_macros.h"
+#undef BEGIN_INTERFACE
+#define BEGIN_INTERFACE(BaseClass, PPInterface, InterfaceString) \
+    BaseClass##interface_(new BaseClass##Mock),
+#include "nacl_mounts/pepper/all_interfaces.h"
+#include "nacl_mounts/pepper/undef_macros.h"
 
-MessagingInterfaceMock* PepperInterfaceMock::GetMessagingInterface() {
-  return messaging_interface_;
+    // Dummy value so we can ensure that no interface ends the initializer list.
+    dummy_(0) {
 }
 
-VarInterfaceMock* PepperInterfaceMock::GetVarInterface() {
-  return var_interface_;
-}
-
-ConsoleInterfaceMock::ConsoleInterfaceMock() {
-}
-
-ConsoleInterfaceMock::~ConsoleInterfaceMock() {
-}
-
-FileSystemInterfaceMock::FileSystemInterfaceMock() {
-}
-
-FileSystemInterfaceMock::~FileSystemInterfaceMock() {
-}
-
-FileRefInterfaceMock::FileRefInterfaceMock() {
-}
-
-FileRefInterfaceMock::~FileRefInterfaceMock() {
-}
-
-FileIoInterfaceMock::FileIoInterfaceMock() {
-}
-
-FileIoInterfaceMock::~FileIoInterfaceMock() {
-}
-
-DirectoryReaderInterfaceMock::DirectoryReaderInterfaceMock() {
-}
-
-DirectoryReaderInterfaceMock::~DirectoryReaderInterfaceMock() {
-}
+PepperInterfaceMock::~PepperInterfaceMock() {
 
-MessagingInterfaceMock::MessagingInterfaceMock() {
-}
+  // Delete interfaces.
+#include "nacl_mounts/pepper/define_empty_macros.h"
+#undef BEGIN_INTERFACE
+#define BEGIN_INTERFACE(BaseClass, PPInterface, InterfaceString) \
+    delete BaseClass##interface_;
+#include "nacl_mounts/pepper/all_interfaces.h"
+#include "nacl_mounts/pepper/undef_macros.h"
 
-MessagingInterfaceMock::~MessagingInterfaceMock() {
 }
 
-VarInterfaceMock::VarInterfaceMock() {
+PP_Instance PepperInterfaceMock::GetInstance() {
+  return instance_;
 }
 
-VarInterfaceMock::~VarInterfaceMock() {
-}
+// Define Getter functions, constructors, destructors.
+#include "nacl_mounts/pepper/define_empty_macros.h"
+#undef BEGIN_INTERFACE
+#define BEGIN_INTERFACE(BaseClass, PPInterface, InterfaceString) \
+    BaseClass##Mock* PepperInterfaceMock::Get##BaseClass() { \
+      return BaseClass##interface_; \
+    } \
+    BaseClass##Mock::BaseClass##Mock() { \
+    } \
+    BaseClass##Mock::~BaseClass##Mock() { \
+    }
+#include "nacl_mounts/pepper/all_interfaces.h"
+#include "nacl_mounts/pepper/undef_macros.h"
diff --git a/native_client_sdk/src/libraries/nacl_mounts_test/pepper_interface_mock.h b/native_client_sdk/src/libraries/nacl_mounts_test/pepper_interface_mock.h
index 540a7a3..bd2ab53 100644
--- a/native_client_sdk/src/libraries/nacl_mounts_test/pepper_interface_mock.h
+++ b/native_client_sdk/src/libraries/nacl_mounts_test/pepper_interface_mock.h
@@ -8,80 +8,28 @@
 #include "gmock/gmock.h"
 #include "nacl_mounts/pepper_interface.h"
 
-class ConsoleInterfaceMock : public ConsoleInterface {
- public:
-  ConsoleInterfaceMock();
-  virtual ~ConsoleInterfaceMock();
-
-  MOCK_METHOD3(Log, void(PP_Instance, PP_LogLevel, struct PP_Var));
-};
-
-class FileSystemInterfaceMock : public FileSystemInterface {
- public:
-  FileSystemInterfaceMock();
-  virtual ~FileSystemInterfaceMock();
-
-  MOCK_METHOD2(Create, PP_Resource(PP_Instance, PP_FileSystemType));
-  MOCK_METHOD3(Open, int32_t(PP_Resource, int64_t, PP_CompletionCallback));
-};
+// Mock interface class definitions.
+#define BEGIN_INTERFACE(BaseClass, PPInterface, InterfaceString) \
+    class BaseClass##Mock : public BaseClass { \
+     public: \
+      BaseClass##Mock(); \
+      virtual ~BaseClass##Mock();
+#define END_INTERFACE(BaseClass, PPInterface) \
+    };
+#define METHOD1(Class, ReturnType, MethodName, Type0) \
+    MOCK_METHOD1(MethodName, ReturnType(Type0));
+#define METHOD2(Class, ReturnType, MethodName, Type0, Type1) \
+    MOCK_METHOD2(MethodName, ReturnType(Type0, Type1));
+#define METHOD3(Class, ReturnType, MethodName, Type0, Type1, Type2) \
+    MOCK_METHOD3(MethodName, ReturnType(Type0, Type1, Type2));
+#define METHOD4(Class, ReturnType, MethodName, Type0, Type1, Type2, Type3) \
+    MOCK_METHOD4(MethodName, ReturnType(Type0, Type1, Type2, Type3));
+#define METHOD5(Class, ReturnType, MethodName, Type0, Type1, Type2, Type3, \
+                Type4) \
+    MOCK_METHOD5(MethodName, ReturnType(Type0, Type1, Type2, Type3, Type4));
+#include "nacl_mounts/pepper/all_interfaces.h"
+#include "nacl_mounts/pepper/undef_macros.h"
 
-class FileRefInterfaceMock : public FileRefInterface {
- public:
-  FileRefInterfaceMock();
-  virtual ~FileRefInterfaceMock();
-
-  MOCK_METHOD2(Create, PP_Resource(PP_Resource, const char*));
-  MOCK_METHOD2(Delete, int32_t(PP_Resource, PP_CompletionCallback));
-  MOCK_METHOD1(GetName, PP_Var(PP_Resource));
-  MOCK_METHOD3(MakeDirectory, int32_t(PP_Resource, PP_Bool,
-        PP_CompletionCallback));
-};
-
-class FileIoInterfaceMock : public FileIoInterface {
- public:
-  FileIoInterfaceMock();
-  virtual ~FileIoInterfaceMock();
-
-  MOCK_METHOD1(Close, void(PP_Resource));
-  MOCK_METHOD1(Create, PP_Resource(PP_Instance));
-  MOCK_METHOD2(Flush, int32_t(PP_Resource, PP_CompletionCallback));
-  MOCK_METHOD4(Open, int32_t(PP_Resource, PP_Resource, int32_t,
-        PP_CompletionCallback));
-  MOCK_METHOD3(Query, int32_t(PP_Resource, PP_FileInfo*,
-        PP_CompletionCallback));
-  MOCK_METHOD5(Read, int32_t(PP_Resource, int64_t, char*, int32_t,
-        PP_CompletionCallback));
-  MOCK_METHOD3(SetLength, int32_t(PP_Resource, int64_t, PP_CompletionCallback));
-  MOCK_METHOD5(Write, int32_t(PP_Resource, int64_t, const char*, int32_t,
-        PP_CompletionCallback));
-};
-
-class DirectoryReaderInterfaceMock : public DirectoryReaderInterface {
- public:
-  DirectoryReaderInterfaceMock();
-  virtual ~DirectoryReaderInterfaceMock();
-
-  MOCK_METHOD1(Create, PP_Resource(PP_Resource));
-  MOCK_METHOD3(GetNextEntry, int32_t(PP_Resource, PP_DirectoryEntry_Dev*,
-        PP_CompletionCallback));
-};
-
-class MessagingInterfaceMock : public MessagingInterface {
- public:
-  MessagingInterfaceMock();
-  virtual ~MessagingInterfaceMock();
-
-  MOCK_METHOD2(PostMessage, void(PP_Instance, struct PP_Var));
-};
-
-class VarInterfaceMock : public VarInterface {
- public:
-  VarInterfaceMock();
-  virtual ~VarInterfaceMock();
-
-  MOCK_METHOD2(VarFromUtf8, PP_Var(const char*, uint32_t));
-  MOCK_METHOD2(VarToUtf8, const char*(PP_Var, uint32_t*));
-};
 
 class PepperInterfaceMock : public PepperInterface {
  public:
@@ -91,23 +39,27 @@ class PepperInterfaceMock : public PepperInterface {
   virtual PP_Instance GetInstance();
   MOCK_METHOD1(AddRefResource, void(PP_Resource));
   MOCK_METHOD1(ReleaseResource, void(PP_Resource));
-  virtual ConsoleInterfaceMock* GetConsoleInterface();
-  virtual FileSystemInterfaceMock* GetFileSystemInterface();
-  virtual FileRefInterfaceMock* GetFileRefInterface();
-  virtual FileIoInterfaceMock* GetFileIoInterface();
-  virtual DirectoryReaderInterfaceMock* GetDirectoryReaderInterface();
-  virtual MessagingInterfaceMock* GetMessagingInterface();
-  virtual VarInterfaceMock* GetVarInterface();
+
+// Interface getters.
+#include "nacl_mounts/pepper/define_empty_macros.h"
+#undef BEGIN_INTERFACE
+#define BEGIN_INTERFACE(BaseClass, PPInterface, InterfaceString) \
+    virtual BaseClass##Mock* Get##BaseClass();
+#include "nacl_mounts/pepper/all_interfaces.h"
+#include "nacl_mounts/pepper/undef_macros.h"
 
  private:
   PP_Instance instance_;
-  ConsoleInterfaceMock* console_interface_;
-  FileSystemInterfaceMock* filesystem_interface_;
-  FileRefInterfaceMock* fileref_interface_;
-  FileIoInterfaceMock* fileio_interface_;
-  DirectoryReaderInterfaceMock* directory_reader_interface_;
-  MessagingInterfaceMock* messaging_interface_;
-  VarInterfaceMock* var_interface_;
+
+// Interface pointers.
+#include "nacl_mounts/pepper/define_empty_macros.h"
+#undef BEGIN_INTERFACE
+#define BEGIN_INTERFACE(BaseClass, PPInterface, InterfaceString) \
+    BaseClass##Mock* BaseClass##interface_;
+#include "nacl_mounts/pepper/all_interfaces.h"
+#include "nacl_mounts/pepper/undef_macros.h"
+
+  int dummy_;
 };