home *** CD-ROM | disk | FTP | other *** search
/ PC World 2008 February / PCWorld_2008-02_cd.bin / temacd / songbird / Songbird_0.4_windows-i686.exe / xulrunner / components / nsLivemarkService.js < prev    next >
Text File  |  2007-12-19  |  34KB  |  1,057 lines
  1. /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  * ***** BEGIN LICENSE BLOCK *****
  3.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  4.  *
  5.  * The contents of this file are subject to the Mozilla Public License
  6.  * Version 1.1 (the "License"); you may not use this file except in
  7.  * compliance with the License. You may obtain a copy of the License
  8.  * at http://www.mozilla.org/MPL/
  9.  *
  10.  * Software distributed under the License is distributed on an "AS IS"
  11.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  12.  * the License for the specific language governing rights and
  13.  * limitations under the License.
  14.  *
  15.  * The Original Code is the Places JS Livemark Service.
  16.  *
  17.  * The Initial Developer of the Original Code is Mozilla Corporation.
  18.  * Portions created by the Initial Developer are Copyright (C) 2006
  19.  * the Initial Developer. All Rights Reserved.
  20.  *
  21.  * Contributor(s):
  22.  *   Annie Sullivan <annie.sullivan@gmail.com> (C++ author)
  23.  *   Joe Hughes <joe@retrovirus.com>
  24.  *   Vladimir Vukicevic <vladimir@pobox.com>
  25.  *   Masayuki Nakano <masayuki@d-toybox.com>
  26.  *   Robert Sayre <sayrer@gmail.com> (JS port)
  27.  *
  28.  * Alternatively, the contents of this file may be used under the
  29.  * terms of either the GNU General Public License Version 2 or later
  30.  * (the "GPL"), or the GNU Lesser General Public License Version 2.1
  31.  * or later (the "LGPL"), in which case the provisions of the GPL or
  32.  * the LGPL are applicable instead of those above. If you wish to
  33.  * allow use of your version of this file only under the terms of
  34.  * either the GPL or the LGPL, and not to allow others to use your
  35.  * version of this file under the terms of the MPL, indicate your
  36.  * decision by deleting the provisions above and replace them with the
  37.  * notice and other provisions required by the GPL or the LGPL. If you
  38.  * do not delete the provisions above, a recipient may use your
  39.  * version of this file under the terms of any one of the MPL, the GPL
  40.  * or the LGPL.
  41.  *
  42.  * ***** END LICENSE BLOCK ***** */
  43.  
  44. const Cc = Components.classes;
  45. const Ci = Components.interfaces;
  46. const Cr = Components.results;
  47.  
  48. //@line 36 "c:\builds\xulrunner\xr_trunk_dubya\mozilla\toolkit\components\url-classifier\content\moz\lang.js"
  49.  
  50.  
  51. /**
  52.  * lang.js - Some missing JavaScript language features
  53.  */
  54.  
  55. /**
  56.  * Partially applies a function to a particular "this object" and zero or
  57.  * more arguments. The result is a new function with some arguments of the first
  58.  * function pre-filled and the value of |this| "pre-specified".
  59.  *
  60.  * Remaining arguments specified at call-time are appended to the pre-
  61.  * specified ones.
  62.  *
  63.  * Usage:
  64.  * var barMethBound = BindToObject(myFunction, myObj, "arg1", "arg2");
  65.  * barMethBound("arg3", "arg4");
  66.  *
  67.  * @param fn {string} Reference to the function to be bound
  68.  *
  69.  * @param self {object} Specifies the object which |this| should point to
  70.  * when the function is run. If the value is null or undefined, it will default
  71.  * to the global object.
  72.  *
  73.  * @returns {function} A partially-applied form of the speficied function.
  74.  */
  75. function BindToObject(fn, self, opt_args) {
  76.   var boundargs = fn.boundArgs_ || [];
  77.   boundargs = boundargs.concat(Array.slice(arguments, 2, arguments.length));
  78.  
  79.   if (fn.boundSelf_)
  80.     self = fn.boundSelf_;
  81.   if (fn.boundFn_)
  82.     fn = fn.boundFn_;
  83.  
  84.   var newfn = function() {
  85.     // Combine the static args and the new args into one big array
  86.     var args = boundargs.concat(Array.slice(arguments));
  87.     return fn.apply(self, args);
  88.   }
  89.  
  90.   newfn.boundArgs_ = boundargs;
  91.   newfn.boundSelf_ = self;
  92.   newfn.boundFn_ = fn;
  93.  
  94.   return newfn;
  95. }
  96.  
  97. /**
  98.  * Inherit the prototype methods from one constructor into another.
  99.  *
  100.  * Usage:
  101.  *
  102.  * function ParentClass(a, b) { }
  103.  * ParentClass.prototype.foo = function(a) { }
  104.  *
  105.  * function ChildClass(a, b, c) {
  106.  *   ParentClass.call(this, a, b);
  107.  * }
  108.  *
  109.  * ChildClass.inherits(ParentClass);
  110.  *
  111.  * var child = new ChildClass("a", "b", "see");
  112.  * child.foo(); // works
  113.  *
  114.  * In addition, a superclass' implementation of a method can be invoked
  115.  * as follows:
  116.  *
  117.  * ChildClass.prototype.foo = function(a) {
  118.  *   ChildClass.superClass_.foo.call(this, a);
  119.  *   // other code
  120.  * };
  121.  */
  122. Function.prototype.inherits = function(parentCtor) {
  123.   var tempCtor = function(){};
  124.   tempCtor.prototype = parentCtor.prototype;
  125.   this.superClass_ = parentCtor.prototype;
  126.   this.prototype = new tempCtor();
  127. }
  128. //@line 36 "c:\builds\xulrunner\xr_trunk_dubya\mozilla\toolkit\components\url-classifier\content\moz\observer.js"
  129.  
  130.  
  131. // A couple of classes to simplify creating observers. 
  132. //
  133. // // Example1:
  134. //
  135. // function doSomething() { ... }
  136. // var observer = new G_ObserverWrapper(topic, doSomething);
  137. // someObj.addObserver(topic, observer);
  138. //
  139. // // Example2: 
  140. //
  141. // function doSomething() { ... }
  142. // new G_ObserverServiceObserver("profile-after-change", 
  143. //                               doSomething,
  144. //                               true /* run only once */);
  145.  
  146.  
  147. /**
  148.  * This class abstracts the admittedly simple boilerplate required of
  149.  * an nsIObserver. It saves you the trouble of implementing the
  150.  * indirection of your own observe() function.
  151.  *
  152.  * @param topic String containing the topic the observer will filter for
  153.  *
  154.  * @param observeFunction Reference to the function to call when the 
  155.  *                        observer fires
  156.  *
  157.  * @constructor
  158.  */
  159. function G_ObserverWrapper(topic, observeFunction) {
  160.   this.debugZone = "observer";
  161.   this.topic_ = topic;
  162.   this.observeFunction_ = observeFunction;
  163. }
  164.  
  165. /**
  166.  * XPCOM
  167.  */
  168. G_ObserverWrapper.prototype.QueryInterface = function(iid) {
  169.   if (iid.equals(Ci.nsISupports) || iid.equals(Ci.nsIObserver))
  170.     return this;
  171.   throw Components.results.NS_ERROR_NO_INTERFACE;
  172. }
  173.  
  174. /**
  175.  * Invoked by the thingy being observed
  176.  */
  177. G_ObserverWrapper.prototype.observe = function(subject, topic, data) {
  178.   if (topic == this.topic_)
  179.     this.observeFunction_(subject, topic, data);
  180. }
  181.  
  182.  
  183. /**
  184.  * This class abstracts the admittedly simple boilerplate required of
  185.  * observing an observerservice topic. It implements the indirection
  186.  * required, and automatically registers to hear the topic.
  187.  *
  188.  * @param topic String containing the topic the observer will filter for
  189.  *
  190.  * @param observeFunction Reference to the function to call when the 
  191.  *                        observer fires
  192.  *
  193.  * @param opt_onlyOnce Boolean indicating if the observer should unregister
  194.  *                     after it has fired
  195.  *
  196.  * @constructor
  197.  */
  198. function G_ObserverServiceObserver(topic, observeFunction, opt_onlyOnce) {
  199.   this.debugZone = "observerserviceobserver";
  200.   this.topic_ = topic;
  201.   this.observeFunction_ = observeFunction;
  202.   this.onlyOnce_ = !!opt_onlyOnce;
  203.   
  204.   this.observer_ = new G_ObserverWrapper(this.topic_, 
  205.                                          BindToObject(this.observe_, this));
  206.   this.observerService_ = Cc["@mozilla.org/observer-service;1"]
  207.                           .getService(Ci.nsIObserverService);
  208.   this.observerService_.addObserver(this.observer_, this.topic_, false);
  209. }
  210.  
  211. /**
  212.  * Unregister the observer from the observerservice
  213.  */
  214. G_ObserverServiceObserver.prototype.unregister = function() {
  215.   this.observerService_.removeObserver(this.observer_, this.topic_);
  216.   this.observerService_ = null;
  217. }
  218.  
  219. /**
  220.  * Invoked by the observerservice
  221.  */
  222. G_ObserverServiceObserver.prototype.observe_ = function(subject, topic, data) {
  223.   this.observeFunction_(subject, topic, data);
  224.   if (this.onlyOnce_)
  225.     this.unregister();
  226. }
  227.  
  228. //@line 36 "c:\builds\xulrunner\xr_trunk_dubya\mozilla\toolkit\components\url-classifier\content\moz\alarm.js"
  229.  
  230.  
  231. // An Alarm fires a callback after a certain amount of time, or at
  232. // regular intervals. It's a convenient replacement for
  233. // setTimeout/Interval when you don't want to bind to a specific
  234. // window.
  235. //
  236. // The ConditionalAlarm is an Alarm that cancels itself if its callback 
  237. // returns a value that type-converts to true.
  238. //
  239. // Example:
  240. //
  241. //  function foo() { dump('hi'); };
  242. //  new G_Alarm(foo, 10*1000);                   // Fire foo in 10 seconds
  243. //  new G_Alarm(foo, 10*1000, true /*repeat*/);  // Fire foo every 10 seconds
  244. //  new G_Alarm(foo, 10*1000, true, 7);          // Fire foo every 10 seconds
  245. //                                               // seven times
  246. //  new G_ConditionalAlarm(foo, 1000, true); // Fire every sec until foo()==true
  247. //
  248. //  // Fire foo every 10 seconds until foo returns true or until it fires seven
  249. //  // times, whichever happens first.
  250. //  new G_ConditionalAlarm(foo, 10*1000, true /*repeating*/, 7);
  251. //
  252. // TODO: maybe pass an isFinal flag to the callback if they opted to
  253. // set maxTimes and this is the last iteration?
  254.  
  255.  
  256. /**
  257.  * Set an alarm to fire after a given amount of time, or at specific 
  258.  * intervals.
  259.  *
  260.  * @param callback Function to call when the alarm fires
  261.  * @param delayMS Number indicating the length of the alarm period in ms
  262.  * @param opt_repeating Boolean indicating whether this should fire 
  263.  *                      periodically
  264.  * @param opt_maxTimes Number indicating a maximum number of times to 
  265.  *                     repeat (obviously only useful when opt_repeating==true)
  266.  */
  267. function G_Alarm(callback, delayMS, opt_repeating, opt_maxTimes) {
  268.   this.debugZone = "alarm";
  269.   this.callback_ = callback;
  270.   this.repeating_ = !!opt_repeating;
  271.   this.timer_ = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
  272.   var type = opt_repeating ? 
  273.              this.timer_.TYPE_REPEATING_SLACK : 
  274.              this.timer_.TYPE_ONE_SHOT;
  275.   this.maxTimes_ = opt_maxTimes ? opt_maxTimes : null;
  276.   this.nTimes_ = 0;
  277.  
  278.   this.observerServiceObserver_ = new G_ObserverServiceObserver(
  279.                                         'xpcom-shutdown',
  280.                                         BindToObject(this.cancel, this));
  281.  
  282.   // Ask the timer to use nsITimerCallback (.notify()) when ready
  283.   this.timer_.initWithCallback(this, delayMS, type);
  284. }
  285.  
  286. /**
  287.  * Cancel this timer 
  288.  */
  289. G_Alarm.prototype.cancel = function() {
  290.   if (!this.timer_) {
  291.     return;
  292.   }
  293.  
  294.   this.timer_.cancel();
  295.   // Break circular reference created between this.timer_ and the G_Alarm
  296.   // instance (this)
  297.   this.timer_ = null;
  298.   this.callback_ = null;
  299.  
  300.   // We don't need the shutdown observer anymore
  301.   this.observerServiceObserver_.unregister();
  302. }
  303.  
  304. /**
  305.  * Invoked by the timer when it fires
  306.  * 
  307.  * @param timer Reference to the nsITimer which fired (not currently 
  308.  *              passed along)
  309.  */
  310. G_Alarm.prototype.notify = function(timer) {
  311.   // fire callback and save results
  312.   var ret = this.callback_();
  313.   
  314.   // If they've given us a max number of times to fire, enforce it
  315.   this.nTimes_++;
  316.   if (this.repeating_ && 
  317.       typeof this.maxTimes_ == "number" 
  318.       && this.nTimes_ >= this.maxTimes_) {
  319.     this.cancel();
  320.   } else if (!this.repeating_) {
  321.     // Clear out the callback closure for TYPE_ONE_SHOT timers
  322.     this.cancel();
  323.   }
  324.   // We don't cancel/cleanup timers that repeat forever until either
  325.   // xpcom-shutdown occurs or cancel() is called explicitly.
  326.  
  327.   return ret;
  328. }
  329.  
  330. G_Alarm.prototype.setDelay = function(delay) {
  331.   this.timer_.delay = delay;
  332. }
  333.  
  334. /**
  335.  * XPCOM cruft
  336.  */
  337. G_Alarm.prototype.QueryInterface = function(iid) {
  338.   if (iid.equals(Components.interfaces.nsISupports) ||
  339.       iid.equals(Components.interfaces.nsITimerCallback))
  340.     return this;
  341.  
  342.   throw Components.results.NS_ERROR_NO_INTERFACE;
  343. }
  344.  
  345.  
  346. /**
  347.  * An alarm with the additional property that it cancels itself if its 
  348.  * callback returns true.
  349.  *
  350.  * For parameter documentation, see G_Alarm
  351.  */
  352. function G_ConditionalAlarm(callback, delayMS, opt_repeating, opt_maxTimes) {
  353.   G_Alarm.call(this, callback, delayMS, opt_repeating, opt_maxTimes);
  354.   this.debugZone = "conditionalalarm";
  355. }
  356.  
  357. G_ConditionalAlarm.inherits(G_Alarm);
  358.  
  359. /**
  360.  * Invoked by the timer when it fires
  361.  * 
  362.  * @param timer Reference to the nsITimer which fired (not currently 
  363.  *              passed along)
  364.  */
  365. G_ConditionalAlarm.prototype.notify = function(timer) {
  366.   // Call G_Alarm::notify
  367.   var rv = G_Alarm.prototype.notify.call(this, timer);
  368.  
  369.   if (this.repeating_ && rv) {
  370.     G_Debug(this, "Callback of a repeating alarm returned true; cancelling.");
  371.     this.cancel();
  372.   }
  373. }
  374. //@line 51 "c:\builds\xulrunner\xr_trunk_dubya\mozilla\toolkit\components\places\src\nsLivemarkService.js"
  375.  
  376. function LOG(str) {
  377.   dump("*** " + str + "\n");
  378. }
  379.  
  380. const LS_CLASSID = Components.ID("{dca61eb5-c7cd-4df1-b0fb-d0722baba251}");
  381. const LS_CLASSNAME = "Livemark Service";
  382. const LS_CONTRACTID = "@mozilla.org/browser/livemark-service;2";
  383.  
  384. const LIVEMARK_TIMEOUT = 15000; // fire every 15 seconds
  385. const LIVEMARK_ICON_URI = "chrome://browser/skin/places/livemarkItem.png";
  386. const PLACES_BUNDLE_URI = 
  387.   "chrome://browser/locale/places/places.properties";
  388. const DEFAULT_LOAD_MSG = "Live Bookmark loading...";
  389. const DEFAULT_FAIL_MSG = "Live Bookmark feed failed to load.";
  390. const LMANNO_FEEDURI = "livemark/feedURI";
  391. const LMANNO_SITEURI = "livemark/siteURI";
  392. const LMANNO_EXPIRATION = "livemark/expiration";
  393. const LMANNO_LOADFAILED = "livemark/loadfailed";
  394.  
  395. const PS_CONTRACTID = "@mozilla.org/preferences-service;1";
  396. const NH_CONTRACTID = "@mozilla.org/browser/nav-history-service;1";
  397. const AS_CONTRACTID = "@mozilla.org/browser/annotation-service;1";
  398. const OS_CONTRACTID = "@mozilla.org/observer-service;1";
  399. const SB_CONTRACTID = "@mozilla.org/intl/stringbundle;1";
  400. const IO_CONTRACTID = "@mozilla.org/network/io-service;1";
  401. const BMS_CONTRACTID = "@mozilla.org/browser/nav-bookmarks-service;1";
  402. const FAV_CONTRACTID = "@mozilla.org/browser/favicon-service;1";
  403. const LG_CONTRACTID = "@mozilla.org/network/load-group;1";
  404. const FP_CONTRACTID = "@mozilla.org/feed-processor;1";
  405. const SEC_CONTRACTID = "@mozilla.org/scriptsecuritymanager;1";
  406. const IS_CONTRACTID = "@mozilla.org/widget/idleservice;1";
  407. const SEC_FLAGS = Ci.nsIScriptSecurityManager.DISALLOW_INHERIT_PRINCIPAL;
  408.  
  409. // Check every hour by default
  410. var gExpiration = 3600000;
  411.  
  412. // Check every 10 minutes on error
  413. const ERROR_EXPIRATION = 600000;
  414.  
  415. // Don't check when the user is idle for longer than half an hour:
  416. const IDLE_TIMELIMIT = 1800000;
  417.  
  418. var gIoService = Cc[IO_CONTRACTID].getService(Ci.nsIIOService);
  419. var gStringBundle;
  420. function GetString(name)
  421. {
  422.   try {
  423.     if (!gStringBundle) {
  424.       var bundleService = Cc[SB_CONTRACTID].getService(); 
  425.       bundleService = bundleService.QueryInterface(Ci.nsIStringBundleService);
  426.       gStringBundle = bundleService.createBundle(PLACES_BUNDLE_URI);
  427.     }
  428.  
  429.     if (gStringBundle)
  430.       return gStringBundle.GetStringFromName(name);
  431.   } catch (ex) {
  432.     LOG("Exception loading string bundle: " + ex.message);
  433.   }
  434.  
  435.   return null;
  436. }
  437.  
  438. function MarkLivemarkLoadFailed(aFolderId) {
  439.   // if it failed before, too, nothing more to do
  440.   var ans = Cc[AS_CONTRACTID].getService(Ci.nsIAnnotationService);
  441.   if (ans.itemHasAnnotation(aFolderId, LMANNO_LOADFAILED))
  442.     return;
  443.  
  444.   var failedMsg = GetString("bookmarksLivemarkFailed") || DEFAULT_FAIL_MSG;
  445.   var failedURI = gIoService.newURI("about:livemark-failed", null, null);
  446.   var bms = Cc[BMS_CONTRACTID].getService(Ci.nsINavBookmarksService);
  447.   bms.insertBookmark(aFolderId, failedURI, 0, failedMsg);
  448.   ans.setItemAnnotation(aFolderId, LMANNO_LOADFAILED, true, 0,
  449.                         ans.EXPIRE_NEVER);
  450. } 
  451.  
  452. var gLivemarkService;
  453. function LivemarkService() {
  454.  
  455.   try {
  456.     var prefs = Cc[PS_CONTRACTID].getService(Ci.nsIPrefBranch);
  457.     var livemarkRefresh = 
  458.       prefs.getIntPref("browser.bookmarks.livemark_refresh_seconds");
  459.     // Reset global expiration variable to reflect hidden pref (in ms)
  460.     // with a lower limit of 1 minute (60000 ms)
  461.     gExpiration = Math.max(livemarkRefresh * 1000, 60000);
  462.   } 
  463.   catch (ex) { }
  464.  
  465.   // [ {folderId:, folderURI:, feedURI:, loadGroup:, locked: } ];
  466.   this._livemarks = [];
  467.  
  468.   this._iconURI = gIoService.newURI(LIVEMARK_ICON_URI, null, null);
  469.   this._loading = GetString("bookmarksLivemarkLoading") || DEFAULT_LOAD_MSG;
  470.   this._observerServiceObserver =
  471.     new G_ObserverServiceObserver('xpcom-shutdown',
  472.                                   BindToObject(this._shutdown, this),
  473.                                   true /*only once*/);
  474.   new G_Alarm(BindToObject(this._fireTimer, this), LIVEMARK_TIMEOUT, 
  475.               true /* repeat */);
  476.  
  477.   if (IS_CONTRACTID in Cc)
  478.     this._idleService = Cc[IS_CONTRACTID].getService(Ci.nsIIdleService);
  479.  
  480.   // this is giving a reentrant getService warning in XPCShell. bug 194568.
  481.   this._ans = Cc[AS_CONTRACTID].getService(Ci.nsIAnnotationService);
  482.  
  483.   var livemarks = this._ans.getItemsWithAnnotation(LMANNO_FEEDURI, {});
  484.   for (var i = 0; i < livemarks.length; i++) {
  485.     var feedURI =
  486.       gIoService.newURI(
  487.         this._ans.getItemAnnotation(livemarks[i], LMANNO_FEEDURI),
  488.         null, null
  489.       );
  490.     this._pushLivemark(livemarks[i], feedURI);
  491.   }
  492.  
  493.   this._bms.addObserver(this, false);
  494. }
  495.  
  496. LivemarkService.prototype = {
  497.  
  498.   get _bms() {
  499.     if (!this.__bms)
  500.       this.__bms = Cc[BMS_CONTRACTID].getService(Ci.nsINavBookmarksService);
  501.     return this.__bms;
  502.   },
  503.  
  504.   get _history() {
  505.     if (!this.__history)
  506.       this.__history = Cc[NH_CONTRACTID].getService(Ci.nsINavHistoryService);
  507.     return this.__history;
  508.   },
  509.  
  510.   // returns new length of _livemarks
  511.   _pushLivemark: function LS__pushLivemark(folderId, feedURI) {
  512.     return this._livemarks.push({folderId: folderId, feedURI: feedURI});
  513.   },
  514.  
  515.   _getLivemarkIndex: function LS__getLivemarkIndex(folderId) {
  516.     for (var i=0; i < this._livemarks.length; ++i) {
  517.       if (this._livemarks[i].folderId == folderId)
  518.         return i;
  519.     }
  520.     throw Cr.NS_ERROR_INVALID_ARG;
  521.   },
  522.  
  523.   _shutdown: function LS__shutdown() {
  524.     // remove bookmarks observer
  525.     this._bms.removeObserver(this);
  526.  
  527.     for (var livemark in this._livemarks) {
  528.       if (livemark.loadGroup) 
  529.         livemark.loadGroup.cancel(Cr.NS_BINDING_ABORTED);
  530.     }
  531.   },
  532.  
  533.   _fireTimer: function LS__fireTimer() {
  534.     for (var i=0; i < this._livemarks.length; ++i) {
  535.       this._updateLivemarkChildren(i, false);
  536.     }
  537.   },
  538.  
  539.   deleteLivemarkChildren: function LS_deleteLivemarkChildren(folderId) {
  540.     this._bms.removeFolderChildren(folderId);
  541.   },
  542.  
  543.   insertLivemarkLoadingItem: function LS_insertLivemarkLoading(bms, livemark) {
  544.     var loadingURI = gIoService.newURI("about:livemark-loading", null, null);
  545.     if (!livemark.loadingId || livemark.loadingId == -1)
  546.       livemark.loadingId = bms.insertBookmark(livemark.folderId, loadingURI,
  547.                                               0, this._loading);
  548.   },
  549.  
  550.   _updateLivemarkChildren:
  551.   function LS__updateLivemarkChildren(index, forceUpdate) {
  552.     if (this._livemarks[index].locked)
  553.       return;
  554.  
  555.     var livemark = this._livemarks[index];
  556.     livemark.locked = true;
  557.     try {
  558.       // Check the TTL/expiration on this.  If there isn't one,
  559.       // then we assume it's never been loaded.  We perform this
  560.       // check even when the update is being forced, in case the
  561.       // livemark has somehow never been loaded.
  562.       var exprTime = this._ans.getPageAnnotation(livemark.feedURI,
  563.                                                  LMANNO_EXPIRATION);
  564.       if (!forceUpdate && exprTime > Date.now()) {
  565.         // no need to refresh
  566.         livemark.locked = false;
  567.         return;
  568.       }
  569.  
  570.       // Check the user idle time. If the user isn't using their computer, don't
  571.       // bother updating - save the internet some bandwidth. If we can't
  572.       // get the idle time, assume the user isn't idle.
  573.       var idleTime = 0;
  574.       try {
  575.         idleTime = this._idleService.idleTime;
  576.       } catch (ex) { /* We don't care */ }
  577.       if (idleTime > IDLE_TIMELIMIT)
  578.       {
  579.         livemark.locked = false;
  580.         return;
  581.       }
  582.     }
  583.     catch (ex) {
  584.       // This livemark has never been loaded, since it has no expire time.
  585.     }
  586.  
  587.     var loadgroup;
  588.     try {
  589.       // Create a load group for the request.  This will allow us to
  590.       // automatically keep track of redirects, so we can always
  591.       // cancel the channel.
  592.       loadgroup = Cc[LG_CONTRACTID].createInstance(Ci.nsILoadGroup);
  593.       var uriChannel = gIoService.newChannel(livemark.feedURI.spec, null, null);
  594.       uriChannel.loadGroup = loadgroup;
  595.       uriChannel.loadFlags |= Ci.nsIRequest.LOAD_BACKGROUND | 
  596.                               Ci.nsIRequest.VALIDATE_ALWAYS;
  597.       var httpChannel = uriChannel.QueryInterface(Ci.nsIHttpChannel);
  598.       httpChannel.requestMethod = "GET";
  599.       httpChannel.setRequestHeader("X-Moz", "livebookmarks", false);
  600.  
  601.       // Stream the result to the feed parser with this listener
  602.       var listener = new LivemarkLoadListener(livemark);
  603.       this.insertLivemarkLoadingItem(this._bms, livemark);
  604.       httpChannel.asyncOpen(listener, null);
  605.     }
  606.     catch (ex) {
  607.       if (livemark.loadingId != -1) {
  608.         this._bms.removeItem(livemark.loadingId);
  609.         livemark.loadingId = -1;
  610.       }
  611.       MarkLivemarkLoadFailed(livemark.folderId);      
  612.       livemark.locked = false;
  613.       LOG("exception: " + ex);
  614.       throw ex;
  615.     }
  616.     livemark.loadGroup = loadgroup;
  617.   },
  618.  
  619.   createLivemark: function LS_createLivemark(folder, name, siteURI,
  620.                                              feedURI, index) {
  621.     // Don't add livemarks to livemarks
  622.     if (this.isLivemark(folder))
  623.       throw Cr.NS_ERROR_INVALID_ARG;
  624.     var livemarkID = this._createFolder(this._bms, folder, name, siteURI,
  625.                                         feedURI, index);
  626.   
  627.     // kick off http fetch
  628.     this._updateLivemarkChildren(
  629.       this._pushLivemark(livemarkID, feedURI) - 1,
  630.       false
  631.     );
  632.  
  633.     return livemarkID;
  634.   },
  635.  
  636.   createLivemarkFolderOnly:
  637.   function LS_createLivemarkFolderOnly(bms, folder, name, siteURI,
  638.                                        feedURI, index) {
  639.     var livemarkID = this._createFolder(bms, folder, name, siteURI, feedURI,
  640.                                         index);
  641.     this._pushLivemark(livemarkID, feedURI);
  642.     var livemarkIndex = this._getLivemarkIndex(livemarkID);
  643.     var livemark = this._livemarks[livemarkIndex];
  644.     this.insertLivemarkLoadingItem(bms, livemark);
  645.     
  646.     return livemarkID;
  647.   },
  648.  
  649.   _createFolder:
  650.   function LS__createFolder(bms, folder, name, siteURI, feedURI, index) {
  651.     var livemarkID = bms.createFolder(folder, name, index);
  652.     this._bms.setFolderReadonly(livemarkID, true);
  653.  
  654.     // Add an annotation to map the folder id to the livemark feed URI
  655.     this._ans.setItemAnnotation(livemarkID, LMANNO_FEEDURI, feedURI.spec, 0,
  656.                                 this._ans.EXPIRE_NEVER);
  657.  
  658.     if (siteURI) {
  659.       // Add an annotation to map the folder URI to the livemark site URI
  660.       this._ans.setItemAnnotation(livemarkID, LMANNO_SITEURI, siteURI.spec,
  661.                                   0, this._ans.EXPIRE_NEVER);
  662.     }
  663.  
  664.     return livemarkID;
  665.   },
  666.  
  667.   isLivemark: function LS_isLivemark(folder) {
  668.     return this._ans.itemHasAnnotation(folder, LMANNO_FEEDURI);
  669.   },
  670.  
  671.   _ensureLivemark: function LS__ensureLivemark(container) {
  672.     if (!this.isLivemark(container)) 
  673.       throw Cr.NS_ERROR_INVALID_ARG;
  674.   },
  675.  
  676.   /**
  677.   * n.b. -- the body of this method is duplicated in 
  678.   *         /browser/components/places/content/toolbar.xml
  679.   *         to avoid instantiating the livemark service on
  680.   *         startup.
  681.   */
  682.   getSiteURI: function LS_getSiteURI(container) {
  683.     this._ensureLivemark(container);
  684.  
  685.     if (this._ans.itemHasAnnotation(container, LMANNO_SITEURI)) {
  686.       var siteURIString =
  687.         this._ans.getItemAnnotation(container, LMANNO_SITEURI);
  688.  
  689.       return gIoService.newURI(siteURIString, null, null);
  690.     }
  691.     return null;
  692.   },
  693.  
  694.   setSiteURI: function LS_setSiteURI(container, siteURI) {
  695.     this._ensureLivemark(container);
  696.     
  697.     if (!siteURI) {
  698.       this._ans.removeItemAnnotation(container, LMANNO_SITEURI);
  699.       return;
  700.     }
  701.  
  702.     this._ans.setItemAnnotation(container, LMANNO_SITEURI, siteURI.spec,
  703.                                       0, this._ans.EXPIRE_NEVER);
  704.   },
  705.  
  706.   getFeedURI: function LS_getFeedURI(container) {
  707.     try {
  708.       // getItemAnnotation() can throw if there is no annotation
  709.       var feedURIString = this._ans.getItemAnnotation(container,
  710.                                                       LMANNO_FEEDURI);
  711.        
  712.       return gIoService.newURI(feedURIString, null, null);
  713.     }
  714.     catch (ex) {
  715.       // temporary logging, for bug #381894
  716.       LOG("getFeedURI failed: " + ex);
  717.       LOG("feedURIString: " + feedURIString);
  718.     }
  719.     return null;
  720.   },
  721.  
  722.   setFeedURI: function LS_setFeedURI(container, feedURI) {
  723.     if (!feedURI)
  724.       throw Cr.NS_ERROR_INVALID_ARG;
  725.  
  726.     this._ans.setItemAnnotation(container, LMANNO_FEEDURI, feedURI.spec, 0,
  727.                                 this._ans.EXPIRE_NEVER);
  728.  
  729.     // now update our internal table
  730.     var livemarkIndex = this._getLivemarkIndex(container);  
  731.     this._livemarks[livemarkIndex].feedURI = feedURI;
  732.   },
  733.  
  734.   reloadAllLivemarks: function LS_reloadAllLivemarks() {
  735.     for (var i = 0; i < this._livemarks.length; ++i) {
  736.       this._updateLivemarkChildren(i, true);
  737.     }
  738.   },
  739.  
  740.   reloadLivemarkFolder: function LS_reloadLivemarkFolder(folderID) {
  741.     var livemarkIndex = this._getLivemarkIndex(folderID);  
  742.     this._updateLivemarkChildren(livemarkIndex, true);
  743.   },
  744.  
  745.   // nsINavBookmarkObserver
  746.   onBeginUpdateBatch: function() { },
  747.   onEndUpdateBatch: function() { },
  748.   onItemAdded: function() { },
  749.   onItemChanged: function() { },
  750.   onItemVisited: function() { },
  751.   onItemMoved: function() { },
  752.  
  753.   onItemRemoved: function(aItemId, aParentFolder, aIndex) {
  754.     try {
  755.       var livemarkIndex = this._getLivemarkIndex(aItemId);
  756.     }
  757.     catch(ex) {
  758.       // not a livemark
  759.       return;
  760.     }
  761.     var livemark = this._livemarks[livemarkIndex];
  762.  
  763.     var stillInUse = false;
  764.     stillInUse = this._livemarks.some(
  765.                  function(mark) { return mark.feedURI.equals(livemark.feedURI) } 
  766.                  );
  767.     if (!stillInUse) {
  768.       // ??? the code in the C++ had "livemark_expiration" as
  769.       // the second arg... that must be wrong
  770.       this._ans.removePageAnnotation(livemark.feedURI, LMANNO_EXPIRATION);
  771.     }
  772.  
  773.     if (livemark.loadGroup) 
  774.       livemark.loadGroup.cancel(Cr.NS_BINDING_ABORTED);
  775.     this._livemarks.splice(livemarkIndex, 1);
  776.   },
  777.  
  778.   createInstance: function LS_createInstance(outer, iid) {
  779.     if (outer != null)
  780.       throw Cr.NS_ERROR_NO_AGGREGATION;
  781.     return this.QueryInterface(iid);
  782.   },
  783.   
  784.   QueryInterface: function LS_QueryInterface(iid) {
  785.     if (iid.equals(Ci.nsILivemarkService) ||
  786.         iid.equals(Ci.nsIFactory) ||
  787.         iid.equals(Ci.nsINavBookmarkObserver) ||
  788.         iid.equals(Ci.nsISupports))
  789.       return this;
  790.     throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  791.   }
  792. };
  793.  
  794. function LivemarkLoadListener(livemark) {
  795.   this._livemark = livemark;
  796.   this._livemark.loadingId = -1;
  797.   this._processor = null;
  798.   this._isAborted = false;
  799.   this._ttl = gExpiration;
  800.   this._ans = Cc[AS_CONTRACTID].getService(Ci.nsIAnnotationService);
  801. }
  802.  
  803. LivemarkLoadListener.prototype = {
  804.  
  805.   abort: function LLL_abort() {
  806.     this._isAborted = true;
  807.   },
  808.  
  809.   get _bms() {
  810.     if (!this.__bms)
  811.       this.__bms = Cc[BMS_CONTRACTID].getService(Ci.nsINavBookmarksService);
  812.     return this.__bms;
  813.   },
  814.  
  815.   get _history() {
  816.     if (!this.__history)
  817.       this.__history = Cc[NH_CONTRACTID].getService(Ci.nsINavHistoryService);
  818.     return this.__history;
  819.   },
  820.  
  821.   // called back from handleResult
  822.   runBatched: function LLL_runBatched(aUserData) {
  823.     var result = aUserData.QueryInterface(Ci.nsIFeedResult);
  824.  
  825.     // We need this to make sure the item links are safe
  826.     var secMan = Cc[SEC_CONTRACTID].getService(Ci.nsIScriptSecurityManager);
  827.       
  828.     // Clear out any child nodes of the livemark folder, since
  829.     // they're about to be replaced.
  830.     var lmService = Cc[LS_CONTRACTID].getService(Ci.nsILivemarkService);
  831.  
  832.     // Enforce well-formedness because the existing code does
  833.     if (!result || !result.doc || result.bozo) {
  834.       if (this._livemark.loadingId != -1) {
  835.         this._bms.removeItem(this._livemark.loadingId);
  836.         this._livemark.loadingId = -1;
  837.       }
  838.       MarkLivemarkLoadFailed(this._livemark.folderId);
  839.       this._ttl = gExpiration;
  840.       throw Cr.NS_ERROR_FAILURE;
  841.     }
  842.  
  843.     this.deleteLivemarkChildren(this._livemark.folderId);
  844.     this._livemark.loadingId = -1;
  845.     // removeItemAnnotation can safely be used even when the anno isn't set
  846.     this._ans.removeItemAnnotation(this._livemark.folderId, LMANNO_LOADFAILED);
  847.     var feed = result.doc.QueryInterface(Ci.nsIFeed);
  848.     // Loop through and check for a link and a title
  849.     // as the old code did
  850.     for (var i = 0; i < feed.items.length; ++i) {
  851.       let entry = feed.items.queryElementAt(i, Ci.nsIFeedEntry);
  852.       let href = entry.link;
  853.       if (!href)
  854.         continue;
  855.  
  856.       let title = entry.title ? entry.title.plainText() : entry.updated;
  857.       if (!title)
  858.         continue;
  859.  
  860.       try {
  861.         secMan.checkLoadURIStr(this._livemark.feedURI.spec, href.spec,
  862.                                SEC_FLAGS);
  863.       }
  864.       catch(ex) {
  865.         continue;
  866.       }
  867.  
  868.       this.insertLivemarkChild(this._livemark.folderId, href, title);
  869.     }
  870.   },
  871.  
  872.   /**
  873.    * See nsIFeedResultListener.idl
  874.    */
  875.   handleResult: function LLL_handleResult(result) {
  876.     if (this._isAborted) {
  877.       if (this._livemark.loadingId != -1) {
  878.         this._bms.removeItem(this._livemark.loadingId);
  879.         this._livemark.loadingId = -1;
  880.       }
  881.       MarkLivemarkLoadFailed(this._livemark.folderId);
  882.       this._livemark.locked = false;
  883.       return;
  884.     }
  885.     try {
  886.       // The actual work is done in runBatched, see above.
  887.       this._bms.runInBatchMode(this, result);
  888.     }
  889.     finally {
  890.       this._processor.listener = null;
  891.       this._processor = null;
  892.       this._livemark.locked = false;
  893.     }
  894.   },
  895.   
  896.   deleteLivemarkChildren: LivemarkService.prototype.deleteLivemarkChildren,
  897.  
  898.   insertLivemarkChild:
  899.   function LS_insertLivemarkChild(folderId, uri, title) {
  900.     var id = this._bms.insertBookmark(folderId, uri, this._bms.DEFAULT_INDEX,
  901.                                       title);
  902.   },
  903.  
  904.   /**
  905.    * See nsIStreamListener.idl
  906.    */
  907.   onDataAvailable: function LLL_onDataAvailable(request, context, inputStream, 
  908.                                                 sourceOffset, count) {
  909.     this._processor.onDataAvailable(request, context, inputStream,
  910.                                     sourceOffset, count);
  911.   },
  912.   
  913.   /**
  914.    * See nsIRequestObserver.idl
  915.    */
  916.   onStartRequest: function LLL_onStartRequest(request, context) {
  917.     if (this._isAborted)
  918.       throw Cr.NS_ERROR_UNEXPECTED;
  919.  
  920.     var channel = request.QueryInterface(Ci.nsIChannel);
  921.  
  922.     // Parse feed data as it comes in
  923.     this._processor = Cc[FP_CONTRACTID].createInstance(Ci.nsIFeedProcessor);
  924.     this._processor.listener = this;
  925.     this._processor.parseAsync(null, channel.URI);
  926.     
  927.     this._processor.onStartRequest(request, context);
  928.   },
  929.   
  930.   /**
  931.    * See nsIRequestObserver.idl
  932.    */
  933.   onStopRequest: function LLL_onStopRequest(request, context, status) {
  934.     if (!Components.isSuccessCode(status)) {
  935.       // Something went wrong; try to load again in a bit
  936.       this._setResourceTTL(ERROR_EXPIRATION);
  937.       this._isAborted = true;
  938.       if (this._livemark.loadingId != -1) {
  939.         this._bms.removeItem(this._livemark.loadingId);
  940.         this._livemark.loadingId = -1;
  941.       }
  942.       MarkLivemarkLoadFailed(this._livemark.folderId);
  943.       this._livemark.locked = false;
  944.       return;
  945.     }
  946.     // Set an expiration on the livemark, for reloading the data
  947.     try { 
  948.       this._processor.onStopRequest(request, context, status);
  949.  
  950.       // Calculate a new ttl
  951.       var channel = request.QueryInterface(Ci.nsICachingChannel);
  952.       if (channel) {
  953.         var entryInfo = channel.cacheToken.QueryInterface(Ci.nsICacheEntryInfo);
  954.         if (entryInfo) {
  955.           // nsICacheEntryInfo returns value as seconds, 
  956.           // expiresTime stores as ms
  957.           var expiresTime = entryInfo.expirationTime * 1000;
  958.           var nowTime = Date.now();
  959.           
  960.           // note, expiresTime can be 0, see bug #383538
  961.           if (expiresTime > nowTime) {
  962.             this._setResourceTTL(Math.max((expiresTime - nowTime),
  963.                                  gExpiration));
  964.             return;
  965.           }
  966.         }
  967.       }
  968.     }
  969.     catch (ex) { }
  970.     this._setResourceTTL(this._ttl);
  971.   },
  972.  
  973.   _setResourceTTL: function LLL__setResourceTTL(milliseconds) {
  974.     var exptime = Date.now() + milliseconds;
  975.     this._ans.setPageAnnotation(this._livemark.feedURI, LMANNO_EXPIRATION,
  976.                                 exptime, 0,
  977.                                 Ci.nsIAnnotationService.EXPIRE_NEVER);
  978.   },
  979.   
  980.   /**
  981.    * See nsISupports.idl
  982.    */
  983.   QueryInterface: function LLL_QueryInterface(iid) {
  984.     if (iid.equals(Ci.nsIFeedResultListener) ||
  985.         iid.equals(Ci.nsIStreamListener) ||
  986.         iid.equals(Ci.nsIRequestObserver)||
  987.         iid.equals(Ci.nsINavHistoryBatchCallback) ||
  988.         iid.equals(Ci.nsISupports))
  989.       return this;
  990.     throw Cr.NS_ERROR_NO_INTERFACE;
  991.   },
  992. }
  993.  
  994. function GenericComponentFactory(ctor) {
  995.   this._ctor = ctor;
  996. }
  997.  
  998. GenericComponentFactory.prototype = {
  999.  
  1000.   _ctor: null,
  1001.  
  1002.   // nsIFactory
  1003.   createInstance: function(outer, iid) {
  1004.     if (outer != null)
  1005.       throw Cr.NS_ERROR_NO_AGGREGATION;
  1006.     return (new this._ctor()).QueryInterface(iid);
  1007.   },
  1008.  
  1009.   // nsISupports
  1010.   QueryInterface: function(iid) {
  1011.     if (iid.equals(Ci.nsIFactory) ||
  1012.         iid.equals(Ci.nsISupports))
  1013.       return this;
  1014.     throw Cr.NS_ERROR_NO_INTERFACE;
  1015.   },
  1016.  
  1017. };
  1018.  
  1019. var Module = {
  1020.   QueryInterface: function(iid) {
  1021.     if (iid.equals(Ci.nsIModule) || 
  1022.         iid.equals(Ci.nsISupports))
  1023.       return this;
  1024.  
  1025.     throw Cr.NS_ERROR_NO_INTERFACE;
  1026.   },
  1027.  
  1028.   getClassObject: function M_getClassObject(cm, cid, iid) {
  1029.     if (!iid.equals(Ci.nsIFactory))
  1030.       throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  1031.     if (cid.equals(LS_CLASSID))
  1032.       return new GenericComponentFactory(LivemarkService);
  1033.  
  1034.     throw Cr.NS_ERROR_NO_INTERFACE;
  1035.   },
  1036.  
  1037.   registerSelf: function(cm, file, location, type) {
  1038.     var cr = cm.QueryInterface(Ci.nsIComponentRegistrar);
  1039.  
  1040.     cr.registerFactoryLocation(LS_CLASSID, LS_CLASSNAME,
  1041.       LS_CONTRACTID, file, location, type);    
  1042.   },
  1043.  
  1044.   unregisterSelf: function M_unregisterSelf(cm, location, type) {
  1045.     var cr = cm.QueryInterface(Ci.nsIComponentRegistrar);
  1046.     cr.unregisterFactoryLocation(LS_CLASSID, location);
  1047.   },
  1048.   
  1049.   canUnload: function M_canUnload(cm) {
  1050.     return true;
  1051.   }
  1052. };
  1053.  
  1054. function NSGetModule(cm, file) {
  1055.   return Module;
  1056. }
  1057.