Sync current wallpaper

chrome/browser/resources/chromeos/wallpaper_manager/js/util.js

 // Copyright (c) 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.
 
+var globalStrings = null;

[bshe, 2014/09/24 17:07:05]

define all globals and functions in WallpaperUtil namespace. This way, we are
not poluting the global namespace. 

e.g. 

WallpaperUtil.globalStrings = null;

[Ran, 2014/09/24 22:01:35]

Acknowledged.

[Ran, 2014/09/26 17:34:53]

Done.

+function enableSync(callback) {
+  if (globalStrings) {
+    if (globalStrings.isSyncCustomWallpaper)
+      callback();
+  }
+  else {
+    chrome.wallpaperPrivate.getStrings(function(strings) {
+        globalStrings = strings;
+        if (globalStrings.isSyncCustomWallpaper)
+          callback();
+      });
+  }
+}
+
+function errorHandler(e) {
+  console.error(e);
+}
+
+function writeFile(fileEntry, picData, writeCallback) {
+  fileEntry.createWriter(function(fileWriter) {
+    var blob = new Blob([new Int8Array(picData)],
+                        {'type' : 'image\/jpeg'});

[bshe, 2014/09/24 17:07:05]

Did you try png wallpapers? We also support png files.

[Ran, 2014/09/24 22:19:22]

Yes, I tried png wallpapers and sync works as well.

[Ran, 2014/09/26 17:34:54]

Done.

+    fileWriter.write(blob);
+    if (writeCallback) writeCallback();
+  },errorHandler);
+}
+
+function writeWallpaperToSync(wallpaperFilename, picData, writeCallback) {
+  var writeWallpaperToSyncCallback = function(fs) {
+      if (!fs) return;
+      fs.root.getFile(wallpaperFilename,
+                      {create: false},
+                      function() { writeCallback();}, //already exists
+                      function(e) { //not exists, create
+                        fs.root.getFile(wallpaperFilename,
+                                        {create: true},
+                                        function(fe) {
+                                          writeFile(fe, picData, writeCallback);
+                                        },
+                                        errorHandler);
+                      });
+  };
+  chrome.syncFileSystem.requestFileSystem(writeWallpaperToSyncCallback);
+}
+
+function storePictureToLocal(picData, loadDir, picName) {
+  if (!picData) return; //TODO
+  var getDirSuccess = function(dirEntry) {
+    dirEntry.getFile(picName,
+                    {create: false},
+                    function() {}, //already exists
+                    function(e) {  //not exists, create
+                    dirEntry.getFile(picName,
+                                    {create: true},
+                                    function(fe) {
+                                      writeFile(fe, picData);
+                                    },
+                                    errorHandler);
+                    });
+  };
+  window.webkitRequestFileSystem(window.PERSISTENT, 1024 * 1024 * 100,
+                                 function(fs) {
+                                 fs.root.getDirectory(loadDir, {create: true},
+                                                  getDirSuccess, errorHandler);
+                                 },
+                                 errorHandler);
+}
+
+var setWallpaperFromSyncLastCallFinished = true;
+function setWallpaperByName(wallpaperFilename, wallpaperLayout, successCall) {
+  if (!setWallpaperFromSyncLastCallFinished) return;
+  setWallpaperFromSyncLastCallFinished = false;
+  var setWallpaperFromSyncCallback = function(fs) {
+    if (!fs) {
+      errorHandler('fs is null');
+      return;
+    }
+    if (!wallpaperFilename) {
+      errorHandler('wallpaperFilename is null');
+      return;
+    }
+    if (!wallpaperLayout)
+      wallpaperLayout = 'CENTER_CROPPED';
+    fs.root.getFile(wallpaperFilename, {create: false}, function(fileEntry) {
+        fileEntry.file(function(file) {
+           var reader = new FileReader();
+           reader.onloadend = function() {
+            chrome.wallpaperPrivate.setCustomWallpaper(
+               reader.result,
+               wallpaperLayout,
+               true,
+               wallpaperFilename,
+               function(thumbnailData) {
+                 if (!thumbnailData) {
+                    errorHandler('thumbnailData is null!');
+                    //setWallpaperFromSyncCallback();
+                  }
+                  else {
+                    storePictureToLocal(reader.result,
+                                        'original',
+                                        wallpaperFilename);
+                    storePictureToLocal(thumbnailData,
+                                        'thumbnail',
+                                        wallpaperFilename);
+                    if (successCall)
+                      successCall();
+                    setWallpaperFromSyncLastCallFinished = true;
+                  }
+               }
+              );
+           };
+           reader.readAsArrayBuffer(file);
+        },errorHandler);
+      },function(e) { //fail to read file, expected due to download delay
+        setWallpaperFromSyncLastCallFinished = true;
+      });
+  };
+  chrome.syncFileSystem.requestFileSystem(setWallpaperFromSyncCallback);

[bshe, 2014/09/24 17:07:05]

We can probably save fs to a local variable so that we dont need to request it
everytime before we use it.

[Ran, 2014/09/26 17:34:53]

Done.

+}
+
 var WallpaperUtil = {};
 
 /**
  * Saves value to local storage that associates with key.
  * @param {string} key The key that associates with value.
  * @param {string} value The value to save to local storage.
  * @param {boolen} sync True if the value is saved to sync storage.
  * @param {function=} opt_callback The callback on success, or on failure.
  */
 WallpaperUtil.saveToStorage = function(key, value, sync, opt_callback) {
@@ skipping 82 matching lines @@
         chrome.wallpaperPrivate.setWallpaper(xhr.response, layout, url,
                                              onSuccess);
         self.saveWallpaperInfo(url, layout,
                                Constants.WallpaperSourceEnum.Online);
       } else {
         onFailure();
       }
     }, onFailure);
   });
 };