Cleanup the docs of process object

atom/common/api/atom_bindings.cc

@@ -34,14 +34,14 @@ void Hang() {
 }
 
 v8::Local<v8::Value> GetProcessMemoryInfo(v8::Isolate* isolate) {
-  mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
   std::unique_ptr<base::ProcessMetrics> metrics(
-    base::ProcessMetrics::CreateCurrentProcessMetrics());
+      base::ProcessMetrics::CreateCurrentProcessMetrics());
 
+  mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
   dict.Set("workingSetSize",
-    static_cast<double>(metrics->GetWorkingSetSize() >> 10));
+           static_cast<double>(metrics->GetWorkingSetSize() >> 10));
   dict.Set("peakWorkingSetSize",
-    static_cast<double>(metrics->GetPeakWorkingSetSize() >> 10));
+           static_cast<double>(metrics->GetPeakWorkingSetSize() >> 10));
 
   size_t private_bytes, shared_bytes;
   if (metrics->GetMemoryBytes(&private_bytes, &shared_bytes)) {
@@ -52,24 +52,22 @@ v8::Local<v8::Value> GetProcessMemoryInfo(v8::Isolate* isolate) {
   return dict.GetHandle();
 }
 
-v8::Local<v8::Value> GetSystemMemoryInfo(
-    v8::Isolate* isolate,
-    mate::Arguments* args) {
-  mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
-  base::SystemMemoryInfoKB memInfo;
-
-  if (!base::GetSystemMemoryInfo(&memInfo)) {
+v8::Local<v8::Value> GetSystemMemoryInfo(v8::Isolate* isolate,
+                                         mate::Arguments* args) {
+  base::SystemMemoryInfoKB mem_info;
+  if (!base::GetSystemMemoryInfo(&mem_info)) {
     args->ThrowError("Unable to retrieve system memory information");
     return v8::Undefined(isolate);
   }
 
-  dict.Set("total", memInfo.total);
-  dict.Set("free", memInfo.free);
+  mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
+  dict.Set("total", mem_info.total);
+  dict.Set("free", mem_info.free);
 
   // NB: These return bogus values on OS X
 #if !defined(OS_MACOSX)
-  dict.Set("swapTotal", memInfo.swap_total);
-  dict.Set("swapFree", memInfo.swap_free);
+  dict.Set("swapTotal", mem_info.swap_total);
+  dict.Set("swapFree", mem_info.swap_free);
 #endif
 
   return dict.GetHandle();

docs/api/process.md

@@ -1,23 +1,9 @@
 # process
 
-> Get information about the running application process.
-
-The `process` object in Electron has the following differences from the one in
-upstream node:
-
-* `process.type` String - Process's type, can be `browser` (i.e. main process)
-  or `renderer`.
-* `process.versions.electron` String - Version of Electron.
-* `process.versions.chrome` String - Version of Chromium.
-* `process.resourcesPath` String - Path to JavaScript source code.
-* `process.mas` Boolean - For Mac App Store build, this value is `true`, for
-  other builds it is `undefined`.
-* `process.windowsStore` Boolean - If the app is running as a Windows Store app
-  (appx), this value is `true`, for other builds it is `undefined`.
-* `process.defaultApp` Boolean - When app is started by being passed as
-  parameter to the default app, this value is `true` in the main process,
-  otherwise it is `undefined`.
-  
+> Extensions to process object.
+
+The `process` object is extended in Electron with following APIs:
+
 ## Events
 
 ### Event: 'loaded'
@@ -45,6 +31,37 @@ process.once('loaded', () => {
 Setting this to `true` can disable the support for `asar` archives in Node's
 built-in modules.
 
+### `process.type`
+
+Current process's type, can be `"browser"` (i.e. main process) or `"renderer"`.
+
+### `process.versions.electron`
+
+Electron's version string.
+
+### `process.versions.chrome`
+
+Chrome's version string.
+
+### `process.resourcesPath`
+
+Path to the resources directory.
+
+### `process.mas`
+
+For Mac App Store build, this property is `true`, for other builds it is
+`undefined`.
+
+### `process.windowsStore`
+
+If the app is running as a Windows Store app (appx), this property is `true`,
+for otherwise it is `undefined`.
+
+### `process.defaultApp`
+
+When app is started by being passed as parameter to the default app, this
+property is `true` in the main process, otherwise it is `undefined`.
+
 ## Methods
 
 The `process` object has the following method:
@@ -64,33 +81,33 @@ Causes the main thread of the current process hang.
 Sets the file descriptor soft limit to `maxDescriptors` or the OS hard
 limit, whichever is lower for the current process.
 
-### getProcessMemoryInfo()
+### `process.getProcessMemoryInfo()`
 
-Return an object giving memory usage statistics about the current process. Note
+Returns an object giving memory usage statistics about the current process. Note
 that all statistics are reported in Kilobytes.
 
 * `workingSetSize` - The amount of memory currently pinned to actual physical
-  RAM
+  RAM.
 * `peakWorkingSetSize` - The maximum amount of memory that has ever been pinned
-  to actual physical RAM
+  to actual physical RAM.
 * `privateBytes` - The amount of memory not shared by other processes, such as
   JS heap or HTML content.
 * `sharedBytes` - The amount of memory shared between processes, typically
   memory consumed by the Electron code itself
 
-### getSystemMemoryInfo()
+### `process.getSystemMemoryInfo()`
 
-Return an object giving memory usage statistics about the entire system. Note
+Returns an object giving memory usage statistics about the entire system. Note
 that all statistics are reported in Kilobytes.
 
 * `total` - The total amount of physical memory in Kilobytes available to the
-  system
+  system.
 * `free` - The total amount of memory not being used by applications or disk
-  cache
+  cache.
 
 On Windows / Linux:
 
 * `swapTotal` - The total amount of swap memory in Kilobytes available to the
-  system
+  system.
 * `swapFree` - The free amount of swap memory in Kilobytes available to the
-  system
+  system.