Dropping nacl sdk dead code (documentation, project_template).

native_client_sdk/src/project_templates/cc/project_file.cc

Index: native_client_sdk/src/project_templates/cc/project_file.cc
diff --git a/native_client_sdk/src/project_templates/cc/project_file.cc b/native_client_sdk/src/project_templates/cc/project_file.cc
deleted file mode 100644
index c0123fe12840365efd022a5501cbb81feb4fda03..0000000000000000000000000000000000000000
--- a/native_client_sdk/src/project_templates/cc/project_file.cc
+++ /dev/null
@@ -1,87 +0,0 @@
-/// @file <PROJECT_NAME>.cc
-/// This example demonstrates loading, running and scripting a very simple NaCl
-/// module.  To load the NaCl module, the browser first looks for the
-/// CreateModule() factory method (at the end of this file).  It calls
-/// CreateModule() once to load the module code from your .nexe.  After the
-/// .nexe code is loaded, CreateModule() is not called again.
-///
-/// Once the .nexe code is loaded, the browser than calls the CreateInstance()
-/// method on the object returned by CreateModule().  It calls CreateInstance()
-/// each time it encounters an <embed> tag that references your NaCl module.
-///
-/// The browser can talk to your NaCl module via the postMessage() Javascript
-/// function.  When you call postMessage() on your NaCl module from the browser,
-/// this becomes a call to the HandleMessage() method of your pp::Instance
-/// subclass.  You can send messages back to the browser by calling the
-/// PostMessage() method on your pp::Instance.  Note that these two methods
-/// (postMessage() in Javascript and PostMessage() in C++) are asynchronous.
-/// This means they return immediately - there is no waiting for the message
-/// to be handled.  This has implications in your program design, particularly
-/// when mutating property values that are exposed to both the browser and the
-/// NaCl module.
-
-#include <cstdio>
-#include <string>
-#include "ppapi/cpp/instance.h"
-#include "ppapi/cpp/module.h"
-#include "ppapi/cpp/var.h"
-
-/// The Instance class.  One of these exists for each instance of your NaCl
-/// module on the web page.  The browser will ask the Module object to create
-/// a new Instance for each occurence of the <embed> tag that has these
-/// attributes:
-///     type="application/x-nacl"
-///     src="<PROJECT_NAME>.nmf"
-/// To communicate with the browser, you must override HandleMessage() for
-/// receiving messages from the borwser, and use PostMessage() to send messages
-/// back to the browser.  Note that this interface is entirely asynchronous.
-class <ProjectName>Instance : public pp::Instance {
- public:
-  /// The constructor creates the plugin-side instance.
-  /// @param[in] instance the handle to the browser-side plugin instance.
-  explicit <ProjectName>Instance(PP_Instance instance) : pp::Instance(instance)
-  {}
-  virtual ~<ProjectName>Instance() {}
-
-  /// Handler for messages coming in from the browser via postMessage().  The
-  /// @a var_message can contain anything: a JSON string; a string that encodes
-  /// method names and arguments; etc.  For example, you could use
-  /// JSON.stringify in the browser to create a message that contains a method
-  /// name and some parameters, something like this:
-  ///   var json_message = JSON.stringify({ "myMethod" : "3.14159" });
-  ///   nacl_module.postMessage(json_message);
-  /// On receipt of this message in @a var_message, you could parse the JSON to
-  /// retrieve the method name, match it to a function call, and then call it
-  /// with the parameter.
-  /// @param[in] var_message The message posted by the browser.
-  virtual void HandleMessage(const pp::Var& var_message) {
-    // TODO(sdk_user): 1. Make this function handle the incoming message.
-  }
-};
-
-/// The Module class.  The browser calls the CreateInstance() method to create
-/// an instance of your NaCl module on the web page.  The browser creates a new
-/// instance for each <embed> tag with type="application/x-nacl".
-class <ProjectName>Module : public pp::Module {
- public:
-  <ProjectName>Module() : pp::Module() {}
-  virtual ~<ProjectName>Module() {}
-
-  /// Create and return a <ProjectName>Instance object.
-  /// @param[in] instance The browser-side instance.
-  /// @return the plugin-side instance.
-  virtual pp::Instance* CreateInstance(PP_Instance instance) {
-    return new <ProjectName>Instance(instance);
-  }
-};
-
-namespace pp {
-/// Factory function called by the browser when the module is first loaded.
-/// The browser keeps a singleton of this module.  It calls the
-/// CreateInstance() method on the object you return to make instances.  There
-/// is one instance per <embed> tag on the page.  This is the main binding
-/// point for your NaCl module with the browser.
-Module* CreateModule() {
-  return new <ProjectName>Module();
-}
-}  // namespace pp