Reland: HTML Pack Extension Dialog / Linux & Mac Packaging Support

chrome/browser/extensions/extensions_ui.cc

 // Copyright (c) 2006-2009 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/extensions_ui.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/extensions/extension_message_service.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/extensions/extension_updater.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/renderer_host/render_widget_host.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
@@ skipping 18 matching lines @@
 
 ExtensionsUIHTMLSource::ExtensionsUIHTMLSource()
     : DataSource(chrome::kChromeUIExtensionsHost, MessageLoop::current()) {
 }
 
 void ExtensionsUIHTMLSource::StartDataRequest(const std::string& path,
                                               int request_id) {
   DictionaryValue localized_strings;
   localized_strings.SetString(L"title",
       l10n_util::GetString(IDS_EXTENSIONS_TITLE));
+  localized_strings.SetString(L"packDialogHeading",
+      l10n_util::GetString(IDS_EXTENSION_PACK_DIALOG_HEADING));
+  localized_strings.SetString(L"rootDirectoryLabel",
+      l10n_util::GetString(IDS_EXTENSION_PACK_DIALOG_ROOT_DIRECTORY_LABEL));
+  localized_strings.SetString(L"packDialogBrowse",
+      l10n_util::GetString(IDS_EXTENSION_PACK_DIALOG_BROWSE));
+  localized_strings.SetString(L"privateKeyLabel",
+      l10n_util::GetString(IDS_EXTENSION_PACK_DIALOG_PRIVATE_KEY_LABEL));
 
   static const base::StringPiece extensions_html(
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           IDR_EXTENSIONS_UI_HTML));
   std::string full_html(extensions_html.data(), extensions_html.size());
   jstemplate_builder::AppendJsonHtml(&localized_strings, &full_html);
   jstemplate_builder::AppendI18nTemplateSourceHtml(&full_html);
   jstemplate_builder::AppendI18nTemplateProcessHtml(&full_html);
   jstemplate_builder::AppendJsTemplateSourceHtml(&full_html);
 
@@ skipping 24 matching lines @@
   dom_ui_->RegisterMessageCallback("enable",
       NewCallback(this, &ExtensionsDOMHandler::HandleEnableMessage));
   dom_ui_->RegisterMessageCallback("uninstall",
       NewCallback(this, &ExtensionsDOMHandler::HandleUninstallMessage));
   dom_ui_->RegisterMessageCallback("load",
       NewCallback(this, &ExtensionsDOMHandler::HandleLoadMessage));
   dom_ui_->RegisterMessageCallback("pack",
       NewCallback(this, &ExtensionsDOMHandler::HandlePackMessage));
   dom_ui_->RegisterMessageCallback("autoupdate",
       NewCallback(this, &ExtensionsDOMHandler::HandleAutoUpdateMessage));
+  dom_ui_->RegisterMessageCallback("selectFilePath",
+      NewCallback(this, &ExtensionsDOMHandler::HandleSelectFilePathMessage));
 }
 
 void ExtensionsDOMHandler::HandleRequestExtensionsData(const Value* value) {
   DictionaryValue results;
 
   // Add the extensions to the results structure.
   ListValue *extensions_list = new ListValue();
   const ExtensionList* extensions = extensions_service_->extensions();
   for (ExtensionList::const_iterator extension = extensions->begin();
        extension != extensions->end(); ++extension) {
@@ skipping 76 matching lines @@
 void ExtensionsDOMHandler::HandleUninstallMessage(const Value* value) {
   CHECK(value->IsType(Value::TYPE_LIST));
   const ListValue* list = static_cast<const ListValue*>(value);
   CHECK(list->GetSize() == 1);
   std::string extension_id;
   CHECK(list->GetString(0, &extension_id));
   extensions_service_->UninstallExtension(extension_id, false);
 }
 
 void ExtensionsDOMHandler::HandleLoadMessage(const Value* value) {
-  load_extension_dialog_ = SelectFileDialog::Create(this);
-  load_extension_dialog_->SelectFile(
-      SelectFileDialog::SELECT_FOLDER,
-      l10n_util::GetStringUTF16(IDS_EXTENSION_LOAD_FROM_DIRECTORY),
-      FilePath(), NULL, 0, FILE_PATH_LITERAL(""),
-      dom_ui_->tab_contents()->view()->GetTopLevelNativeWindow(), NULL);
+  std::string string_path;
+  CHECK(value->IsType(Value::TYPE_LIST));
+  const ListValue* list = static_cast<const ListValue*>(value);
+  CHECK(list->GetSize() == 1) << list->GetSize();
+  CHECK(list->GetString(0, &string_path));
+  FilePath file_path = FilePath::FromWStringHack(ASCIIToWide(string_path));
+  extensions_service_->LoadExtension(file_path);
+}
+
+void ExtensionsDOMHandler::ShowAlert(const std::string& message) {
+  ListValue arguments;
+  arguments.Append(Value::CreateStringValue(message));
+  dom_ui_->CallJavascriptFunction(L"alert", arguments);
 }
 
 void ExtensionsDOMHandler::HandlePackMessage(const Value* value) {
-#if defined(OS_WIN)
-  ShowPackDialog();
-#endif
+  std::string extension_path;
+  std::string private_key_path;
+  CHECK(value->IsType(Value::TYPE_LIST));
+  const ListValue* list = static_cast<const ListValue*>(value);
+  CHECK(list->GetSize() == 2);
+  CHECK(list->GetString(0, &extension_path));
+  CHECK(list->GetString(1, &private_key_path));
+
+  FilePath root_directory = FilePath::FromWStringHack(ASCIIToWide(
+      extension_path));
+  FilePath key_file = FilePath::FromWStringHack(ASCIIToWide(private_key_path));
+
+  if (root_directory.empty()) {
+    if (extension_path.empty()) {
+      ShowAlert(l10n_util::GetStringUTF8(
+          IDS_EXTENSION_PACK_DIALOG_ERROR_ROOT_REQUIRED));
+    } else {
+      ShowAlert(l10n_util::GetStringUTF8(
+          IDS_EXTENSION_PACK_DIALOG_ERROR_ROOT_INVALID));
+    }
+
+    return;
+  }
+
+  if (!private_key_path.empty() && key_file.empty()) {
+    ShowAlert(l10n_util::GetStringUTF8(
+        IDS_EXTENSION_PACK_DIALOG_ERROR_KEY_INVALID));
+    return;
+  }
+
+  pack_job_ = new PackExtensionJob(this, root_directory, key_file,
+      ChromeThread::GetMessageLoop(ChromeThread::FILE));
+}
+
+void ExtensionsDOMHandler::OnPackSuccess(const FilePath& crx_file,
+                                         const FilePath& pem_file) {
+  std::string message;
+  if (!pem_file.empty()) {
+    message = WideToASCII(l10n_util::GetStringF(
+        IDS_EXTENSION_PACK_DIALOG_SUCCESS_BODY_NEW,
+        crx_file.ToWStringHack(),
+        pem_file.ToWStringHack()));
+  } else {
+    message = WideToASCII(l10n_util::GetStringF(
+        IDS_EXTENSION_PACK_DIALOG_SUCCESS_BODY_UPDATE,
+        crx_file.ToWStringHack()));
+  }
+  ShowAlert(message);
+
+  ListValue results;
+  dom_ui_->CallJavascriptFunction(L"hidePackDialog", results);
+}
+
+void ExtensionsDOMHandler::OnPackFailure(const std::wstring& error) {
+  ShowAlert(WideToASCII(error));
 }
 
 void ExtensionsDOMHandler::HandleAutoUpdateMessage(const Value* value) {
   ExtensionUpdater* updater = extensions_service_->updater();
   if (updater) {
     updater->CheckNow();
   }
 }
 
+void ExtensionsDOMHandler::HandleSelectFilePathMessage(const Value* value) {
+  std::string select_type;
+  std::string operation;
+  CHECK(value->IsType(Value::TYPE_LIST));
+  const ListValue* list = static_cast<const ListValue*>(value);
+  CHECK(list->GetSize() == 2);
+  CHECK(list->GetString(0, &select_type));
+  CHECK(list->GetString(1, &operation));
+
+  SelectFileDialog::Type type = SelectFileDialog::SELECT_FOLDER;
+  static SelectFileDialog::FileTypeInfo info;
+  int file_type_index = 0;
+  if (select_type == "file")
+    type = SelectFileDialog::SELECT_OPEN_FILE;
+
+  string16 select_title;
+  if (operation == "load")
+    select_title = l10n_util::GetStringUTF16(IDS_EXTENSION_LOAD_FROM_DIRECTORY);
+  else if (operation == "packRoot")
+    select_title = l10n_util::GetStringUTF16(
+        IDS_EXTENSION_PACK_DIALOG_SELECT_ROOT);
+  else if (operation == "pem") {
+    select_title = l10n_util::GetStringUTF16(
+        IDS_EXTENSION_PACK_DIALOG_SELECT_KEY);
+    info.extensions.push_back(std::vector<FilePath::StringType>());
+        info.extensions.front().push_back(FILE_PATH_LITERAL("pem"));
+        info.extension_description_overrides.push_back(WideToUTF16(
+            l10n_util::GetString(
+                IDS_EXTENSION_PACK_DIALOG_KEY_FILE_TYPE_DESCRIPTION)));
+        info.include_all_files = true;
+    file_type_index = 1;
+  } else {
+    NOTREACHED();
+    return;
+  }
+
+  load_extension_dialog_ = SelectFileDialog::Create(this);
+  load_extension_dialog_->SelectFile(type, select_title, FilePath(), &info,
+      file_type_index, FILE_PATH_LITERAL(""),
+      dom_ui_->tab_contents()->view()->GetTopLevelNativeWindow(), NULL);
+}
+
+
 void ExtensionsDOMHandler::FileSelected(const FilePath& path, int index,
                                         void* params) {
-  extensions_service_->LoadExtension(path);
+  // Add the extensions to the results structure.
+  ListValue results;
+  results.Append(Value::CreateStringValue(path.value()));
+  dom_ui_->CallJavascriptFunction(L"window.handleFilePathSelected", results);
 }
 
 void ExtensionsDOMHandler::Observe(NotificationType type,
                                    const NotificationSource& source,
                                    const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::EXTENSION_LOADED:
     case NotificationType::EXTENSION_UNLOADED:
     case NotificationType::EXTENSION_UPDATE_DISABLED:
     case NotificationType::EXTENSION_UNLOADED_DISABLED:
@@ skipping 108 matching lines @@
       result.push_back(ExtensionPage((*iter)->url(),
                                      view->process()->id(),
                                      view->routing_id()));
     }
   }
 
   return result;
 }
 
 ExtensionsDOMHandler::~ExtensionsDOMHandler() {
+  if (pack_job_.get())
+    pack_job_->ClearClient();
 }
 
 // ExtensionsDOMHandler, public: -----------------------------------------------
 
 ExtensionsUI::ExtensionsUI(TabContents* contents) : DOMUI(contents) {
   ExtensionsService *exstension_service =
       GetProfile()->GetOriginalProfile()->GetExtensionsService();
 
   ExtensionsDOMHandler* handler = new ExtensionsDOMHandler(exstension_service);
   AddMessageHandler(handler);
   handler->Attach(this);
 
   ExtensionsUIHTMLSource* html_source = new ExtensionsUIHTMLSource();
 
   // Set up the chrome://extensions/ source.
   g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(&chrome_url_data_manager,
           &ChromeURLDataManager::AddDataSource, html_source));
 }