Mac Web Intents Part 1: Show extension download progress

chrome/browser/extensions/webstore_installer.cc

 // 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.
 
 #include "chrome/browser/extensions/webstore_installer.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 118 matching lines @@
     file = file.InsertBeforeExtensionASCII(StringPrintf(" (%d)", uniquifier));
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(callback, file));
 }
 
 }  // namespace
 
 namespace extensions {
 
+void WebstoreInstaller::Delegate::OnExtensionDownloadStarted(
+    const std::string& id,
+    content::DownloadItem* item) {
+}
+
+void WebstoreInstaller::Delegate::OnExtensionDownloadProgress(
+    const std::string& id,
+    content::DownloadItem* item) {
+}
+
 WebstoreInstaller::Approval::Approval()
     : profile(NULL),
       use_app_installed_bubble(false),
       skip_post_install_ui(false),
       skip_install_dialog(false),
       record_oauth2_grant(false) {
 }
 
 scoped_ptr<WebstoreInstaller::Approval>
 WebstoreInstaller::Approval::CreateWithInstallPrompt(Profile* profile) {
@@ skipping 45 matching lines @@
                  content::Source<Profile>(profile->GetOriginalProfile()));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR,
                  content::Source<CrxInstaller>(NULL));
 }
 
 void WebstoreInstaller::Start() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   AddRef();  // Balanced in ReportSuccess and ReportFailure.
 
   if (!Extension::IdIsValid(id_)) {
-    ReportFailure(kInvalidIdError);
+    ReportFailure(kInvalidIdError, FAILURE_REASON_OTHER);
     return;
   }
 
   FilePath download_path = DownloadPrefs::FromDownloadManager(
       BrowserContext::GetDownloadManager(profile_))->DownloadPath();
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&GetDownloadFilePath, download_path, id_,
                  base::Bind(&WebstoreInstaller::StartDownload, this)));
 }
 
 void WebstoreInstaller::Observe(int type,
                                 const content::NotificationSource& source,
                                 const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_CRX_INSTALLER_DONE: {
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
       CrxInstaller* installer = content::Source<CrxInstaller>(source).ptr();
       if (extension == NULL && download_item_ != NULL &&
           installer->download_url() == download_item_->GetURL() &&
           installer->profile()->IsSameProfile(profile_)) {
-        ReportFailure(kInstallCanceledError);
+        ReportFailure(kInstallCanceledError, FAILURE_REASON_CANCELLED);
       }
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_INSTALLED: {
       CHECK(profile_->IsSameProfile(content::Source<Profile>(source).ptr()));
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
       if (id_ == extension->id())
         ReportSuccess();
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR: {
       CrxInstaller* crx_installer = content::Source<CrxInstaller>(source).ptr();
       CHECK(crx_installer);
       if (!profile_->IsSameProfile(crx_installer->profile()))
         return;
 
       // TODO(rdevlin.cronin): Continue removing std::string errors and
       // replacing with string16
       const string16* error = content::Details<const string16>(details).ptr();
       const std::string utf8_error = UTF16ToUTF8(*error);
       if (download_url_ == crx_installer->original_download_url())
-        ReportFailure(utf8_error);
+        ReportFailure(utf8_error, FAILURE_REASON_OTHER);
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
 void WebstoreInstaller::SetDownloadDirectoryForTests(FilePath* directory) {
   g_download_directory_for_tests = directory;
 }
 
 WebstoreInstaller::~WebstoreInstaller() {
   if (download_item_) {
     download_item_->RemoveObserver(this);
     download_item_ = NULL;
   }
 }
 
 void WebstoreInstaller::OnDownloadStarted(DownloadId id, net::Error error) {
   if (error != net::OK) {
-    ReportFailure(net::ErrorToString(error));
+    ReportFailure(net::ErrorToString(error), FAILURE_REASON_OTHER);
     return;
   }
 
   CHECK(id.IsValid());
 
   DownloadManager* download_manager =
       BrowserContext::GetDownloadManager(profile_);
   if (!download_manager)
     return;
   download_item_ = download_manager->GetDownload(id.local());
   // TODO(benjhayden): DCHECK(item && item->IsInProgress()) after investigating
   // the relationship between net::OK and invalid id.
   if (download_item_) {
     download_item_->AddObserver(this);
     if (approval_.get())
       download_item_->SetUserData(kApprovalKey, approval_.release());
+    if (delegate_)
+      delegate_->OnExtensionDownloadStarted(id_, download_item_);
   }
 }
 
 void WebstoreInstaller::OnDownloadUpdated(DownloadItem* download) {
   CHECK_EQ(download_item_, download);
 
   switch (download->GetState()) {
     case DownloadItem::CANCELLED:
-      ReportFailure(kDownloadCanceledError);
+      ReportFailure(kDownloadCanceledError, FAILURE_REASON_CANCELLED);
       break;
     case DownloadItem::INTERRUPTED:
-      ReportFailure(kDownloadInterruptedError);
+      ReportFailure(kDownloadInterruptedError, FAILURE_REASON_OTHER);
       break;
     case DownloadItem::COMPLETE:
       // Wait for other notifications if the download is really an extension.
       if (!download_crx_util::IsExtensionDownload(*download))
-        ReportFailure(kInvalidDownloadError);
+        ReportFailure(kInvalidDownloadError, FAILURE_REASON_OTHER);
+      else if (delegate_)
+        delegate_->OnExtensionDownloadProgress(id_, download);
+      break;
+    case DownloadItem::IN_PROGRESS:
+      if (delegate_)
+        delegate_->OnExtensionDownloadProgress(id_, download);
       break;
     default:
       // Continue listening if the download is not in one of the above states.
       break;
   }
 }
 
 void WebstoreInstaller::OnDownloadDestroyed(DownloadItem* download) {
   CHECK_EQ(download_item_, download);
   download_item_->RemoveObserver(this);
   download_item_ = NULL;
 }
 
 void WebstoreInstaller::StartDownload(const FilePath& file) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DownloadManager* download_manager =
     BrowserContext::GetDownloadManager(profile_);
   if (file.empty() ||
       !download_manager ||
       !controller_->GetWebContents() ||
       !controller_->GetWebContents()->GetRenderProcessHost() ||
       !controller_->GetWebContents()->GetRenderViewHost() ||
       !controller_->GetWebContents()->GetBrowserContext() ||
       !controller_->GetWebContents()->GetBrowserContext()
         ->GetResourceContext()) {
-    ReportFailure(kDownloadDirectoryError);
+    ReportFailure(kDownloadDirectoryError, FAILURE_REASON_OTHER);
     return;
   }
 
   content::DownloadSaveInfo save_info;
   save_info.file_path = file;
 
   // The download url for the given extension is contained in |download_url_|.
   // We will navigate the current tab to this url to start the download. The
   // download system will then pass the crx to the CrxInstaller.
   download_util::RecordDownloadSource(
       download_util::INITIATED_BY_WEBSTORE_INSTALLER);
   scoped_ptr<DownloadUrlParameters> params(
       DownloadUrlParameters::FromWebContents(
           controller_->GetWebContents(), download_url_, save_info));
   if (controller_->GetActiveEntry())
     params->set_referrer(
         content::Referrer(controller_->GetActiveEntry()->GetURL(),
                           WebKit::WebReferrerPolicyDefault));
   params->set_callback(base::Bind(&WebstoreInstaller::OnDownloadStarted, this));
   download_manager->DownloadUrl(params.Pass());
 }
 
-void WebstoreInstaller::ReportFailure(const std::string& error) {
+void WebstoreInstaller::ReportFailure(const std::string& error,
+                                      FailureReason reason) {
   if (delegate_) {
-    delegate_->OnExtensionInstallFailure(id_, error);
+    delegate_->OnExtensionInstallFailure(id_, error, reason);
     delegate_ = NULL;
   }
 
   Release();  // Balanced in Start().
 }
 
 void WebstoreInstaller::ReportSuccess() {
   if (delegate_) {
     delegate_->OnExtensionInstallSuccess(id_);
     delegate_ = NULL;
   }
 
   Release();  // Balanced in Start().
 }
 
 }  // namespace extensions