A few minor changes to the chrome.downloads extension API

chrome/common/extensions/api/downloads.idl

 // Copyright (c) 2012 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.
 
 // Use the <code>chrome.downloads</code> API to programmatically initiate,
 // monitor, manipulate, and search for downloads.
 [permissions=downloads]
 namespace downloads {
   [inline_doc] dictionary HeaderNameValuePair {
     // Name of the HTTP header.
@@ skipping 82 matching lines @@
   enum State {in_progress, interrupted, complete};
 
   // The state of the process of downloading a file.
   dictionary DownloadItem {
     // An identifier that is persistent across browser sessions.
     long id;
 
     // Absolute URL.
     DOMString url;
 
+    // Absolute URL.
+    DOMString referrer;
+
     // Absolute local path.
     DOMString filename;
 
     // False if this download is recorded in the history, true if it is not
     // recorded.
     boolean incognito;
 
     // Indication of whether this download is thought to be safe or known to be
     // suspicious.
     DangerType danger;
 
-    // True if the user has accepted the download's danger.
-    boolean? dangerAccepted;
-
     // The file's MIME type.
     DOMString mime;
 
     // The time when the download began in ISO 8601 format. May be passed
     // directly to the Date constructor: <code>chrome.downloads.search({},
     // function(items){items.forEach(function(item){console.log(new
     // Date(item.startTime))})})</code>
     DOMString startTime;
 
     // The time when the download ended in ISO 8601 format. May be passed
     // directly to the Date constructor: <code>chrome.downloads.search({},
     // function(items){items.forEach(function(item){if (item.endTime)
     // console.log(new Date(item.endTime))})})</code>
     DOMString? endTime;
 
+    // Estimated time when the download will complete in ISO 8601 format.
+    DOMString? estimatedEndTime;
+
     // Indicates whether the download is progressing, interrupted, or complete.
     State state;
 
     // True if the download has stopped reading data from the host, but kept the
     // connection open.
     boolean paused;
 
+    // True if the download is in progress and paused, or else if it is
+    // interrupted and can be resumed starting from where it was interrupted.
+    boolean canResume;
+
     // Number indicating why a download was interrupted.
     long? error;
 
     // Number of bytes received so far from the host, without considering file
     // compression.
     long bytesReceived;
 
     // Number of bytes in the whole file, without considering file compression,
     // or -1 if unknown.
     long totalBytes;
@@ skipping 72 matching lines @@
     // Absolute URL.
     DOMString? url;
 
     // Absolute local path.
     DOMString? filename;
 
     // Indication of whether this download is thought to be safe or known to be
     // suspicious.
     DangerType? danger;
 
-    // True if the user has accepted the download's danger.
-    boolean? dangerAccepted;
-
     // The file's MIME type.
     DOMString? mime;
 
     // The time when the download began in ISO 8601 format.
     DOMString? startTime;
 
     // The time when the download ended in ISO 8601 format.
     DOMString? endTime;
 
     // Indicates whether the download is progressing, interrupted, or complete.
@@ skipping 44 matching lines @@
 
     // The change in <code>url</code>, if any.
     StringDelta? url;
 
     // The change in <code>filename</code>, if any.
     StringDelta? filename;
 
     // The change in <code>danger</code>, if any.
     StringDelta? danger;
 
-    // The change in <code>dangerAccepted</code>, if any.
-    BooleanDelta? dangerAccepted;
-
     // The change in <code>mime</code>, if any.
     StringDelta? mime;
 
     // The change in <code>startTime</code>, if any.
     StringDelta? startTime;
 
     // The change in <code>endTime</code>, if any.
     StringDelta? endTime;
 
     // The change in <code>state</code>, if any.
     StringDelta? state;
 
+    // The change in <code>canResume</code>, if any.
+    BooleanDelta? canResume;
+
     // The change in <code>paused</code>, if any.
     BooleanDelta? paused;
 
     // The change in <code>error</code>, if any.
     LongDelta? error;
 
     // The change in <code>totalBytes</code>, if any.
     LongDelta? totalBytes;
 
     // The change in <code>fileSize</code>, if any.
@@ skipping 82 matching lines @@
                             optional GetFileIconOptions options,
                             GetFileIconCallback callback);
 
     // Open the downloaded file now if the $ref:DownloadItem is complete;
     // returns an error through $ref:runtime.lastError otherwise. An
     // $ref:onChanged event will fire when the item is opened for the first
     // time.
     // |downloadId|: The identifier for the downloaded file.
     static void open(long downloadId);
 
-    // Show the downloaded file in its folder in a file manager.
+    // Show the downloaded file in its folder in a file manager. If
+    // <code>downloadId</code> is not specified, opens the default Downloads
+    // folder in a file manager.
     // |downloadId|: The identifier for the downloaded file.
-    static void show(long downloadId);
+    static void show(optional long downloadId);
 
     // Erase matching $ref:DownloadItem from history. An $ref:onErased event
     // will fire for each $ref:DownloadItem that matches <code>query</code>,
     // then <code>callback</code> will be called.
     static void erase(DownloadQuery query, optional EraseCallback callback);
 
     // Prompt the user to accept a dangerous download. Does not automatically
     // accept dangerous downloads. If the download is accepted, then an
     // $ref:onChanged event will fire, otherwise nothing will happen.  When all
     // the data is fetched into a temporary file and either the download is not
     // dangerous or the danger has been accepted, then the temporary file is
     // renamed to the target filename, the |state| changes to 'complete', and
     // $ref:onChanged fires.
     // |downloadId|: The identifier for the $ref:DownloadItem.
-    static void acceptDanger(long downloadId);
+    // |callback|: Called when the danger prompt dialog closes.
+    static void acceptDanger(long downloadId, optional NullCallback callback);
 
     // Initiate dragging the downloaded file to another application.
     static void drag(long downloadId);
   };
 
   interface Events {
     // This event fires with the $ref:DownloadItem
     // object when a download begins.
     static void onCreated(DownloadItem downloadItem);
 
     // Fires with the <code>downloadId</code> when a download is erased from
     // history.
     // |downloadId|: The <code>id</code> of the $ref:DownloadItem that was
     // erased.
     static void onErased(long downloadId);
 
     // When any of a $ref:DownloadItem's properties except
-    // <code>bytesReceived</code> changes, this event fires with the
-    // <code>downloadId</code> and an object containing the properties that
-    // changed.
+    // <code>bytesReceived</code> and <code>estimatedEndTime</code> changes,
+    // this event fires with the <code>downloadId</code> and an object
+    // containing the properties that changed.
     static void onChanged(DownloadDelta downloadDelta);
 
     // During the filename determination process, extensions will be given the
     // opportunity to override the target $ref:DownloadItem.filename. Each
     // extension may not register more than one listener for this event. Each
     // listener must call <code>suggest</code> exactly once, either
     // synchronously or asynchronously. If the listener calls
     // <code>suggest</code> asynchronously, then it must return
     // <code>true</code>. If the listener neither calls <code>suggest</code>
     // synchronously nor returns <code>true</code>, then <code>suggest</code>
     // will be called automatically. The $ref:DownloadItem will not complete
     // until all listeners have called <code>suggest</code>. Listeners may call
     // <code>suggest</code> without any arguments in order to allow the download
     // to use <code>downloadItem.filename</code> for its filename, or pass a
     // <code>suggestion</code> object to <code>suggest</code> in order to
     // override the target filename. If more than one extension overrides the
     // filename, then the last extension installed whose listener passes a
     // <code>suggestion</code> object to <code>suggest</code> wins. In order to
     // avoid confusion regarding which extension will win, users should not
     // install extensions that may conflict. If the download is initiated by
     // $ref:download and the target filename is known before the MIME type and
     // tentative filename have been determined, pass <code>filename</code> to
     // $ref:download instead.
     [maxListeners=1] static void onDeterminingFilename(
         DownloadItem downloadItem, SuggestFilenameCallback suggest);
   };
 };