--- a/browser/components/sessionstore/SessionWorker.js
+++ b/browser/components/sessionstore/SessionWorker.js
@@ -3,16 +3,18 @@
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
  * A worker dedicated to handle I/O for Session Store.
  */
 
 "use strict";
 
+const { classes: Cc, interfaces: Ci } = Components;
+
 importScripts("resource://gre/modules/osfile.jsm");
 
 var PromiseWorker = require("resource://gre/modules/workers/PromiseWorker.js");
 
 var File = OS.File;
 var Encoder = new TextEncoder();
 var Decoder = new TextDecoder();
 
@@ -78,16 +80,21 @@ var Agent = {
   state: null,
 
   /**
    * Number of old upgrade backups that are being kept
    */
   maxUpgradeBackups: null,
 
   /**
+   * Hash of last written content.
+   */
+  lastWriteHash: null,
+
+  /**
    * Initialize (or reinitialize) the worker
    *
    * @param {string} origin Which of sessionstore.js or its backups
    *   was used. One of the `STATE_*` constants defined above.
    * @param {object} paths The paths at which to find the various files.
    * @param {object} prefs The preferences the worker needs to known.
    */
   init(origin, paths, prefs = {}) {
@@ -145,16 +152,24 @@ var Agent = {
           tab.entries = tab.entries.slice(lower, upper);
           tab.index -= lower;
         }
       }
     }
 
     let stateString = JSON.stringify(state);
     let data = Encoder.encode(stateString);
+
+    let hasher = Cc["@mozilla.org/security/hash;1"]
+                   .createInstance(Ci.nsICryptoHash);
+    hasher.init(hasher.SHA1);
+    hasher.update(data, data.length);
+    let currentHash = hasher.finish(false);
+
+    let performedWrite = false;
     let startWriteMs, stopWriteMs;
 
     try {
 
       if (this.state == STATE_CLEAN || this.state == STATE_EMPTY) {
         // The backups directory may not exist yet. In all other cases,
         // we have either already read from or already written to this
         // directory, so we are satisfied that it exists.
@@ -162,17 +177,18 @@ var Agent = {
       }
 
       if (this.state == STATE_CLEAN) {
         // Move $Path.clean out of the way, to avoid any ambiguity as
         // to which file is more recent.
         File.move(this.Paths.clean, this.Paths.cleanBackup);
       }
 
-      if (true) {
+      /* Avoid I/O if the end result would be the same. */
+      if (currentHash != this.lastWriteHash) {
         startWriteMs = Date.now();
 
         if (options.isFinalWrite) {
           // We are shutting down. At this stage, we know that
           // $Paths.clean is either absent or corrupted. If it was
           // originally present and valid, it has been moved to
           // $Paths.cleanBackup a long time ago. We can therefore write
           // with the guarantees that we erase no important data.
@@ -194,16 +210,18 @@ var Agent = {
           // In other cases, either $Path.recovery is not necessary, or
           // it doesn't exist or it has been corrupted. Regardless,
           // don't backup $Path.recovery.
           File.writeAtomic(this.Paths.recovery, data, {
             tmpPath: this.Paths.recovery + ".tmp"
           });
         }
 
+        performedWrite = true;
+        this.lastWriteHash = currentHash;
         stopWriteMs = Date.now();
       }
 
     } catch (ex) {
       // Don't throw immediately
       exn = exn || ex;
     }
 
@@ -269,31 +287,34 @@ var Agent = {
     }
 
     this.state = STATE_RECOVERY;
 
     if (exn) {
       throw exn;
     }
 
+    if (performedWrite) {
+      telemetry[FX_SESSION_RESTORE_WRITE_FILE_MS] = stopWriteMs - startWriteMs;
+      telemetry[FX_SESSION_RESTORE_FILE_SIZE_BYTES] = data.byteLength;
+    }
+
     return {
       result: {
         upgradeBackup: upgradeBackupComplete
       },
-      telemetry: {
-        FX_SESSION_RESTORE_WRITE_FILE_MS: stopWriteMs - startWriteMs,
-        FX_SESSION_RESTORE_FILE_SIZE_BYTES: data.byteLength,
-      }
+      telemetry: telemetry,
     };
   },
 
   /**
    * Wipes all files holding session data from disk.
    */
   wipe: function () {
+    this.lastWriteHash = null;
 
     // Don't stop immediately in case of error.
     let exn = null;
 
     // Erase main session state file
     try {
       File.remove(this.Paths.clean);
     } catch (ex) {