[Extensions] Make chrome://extensions use developerPrivate for packing crxs

chrome/browser/extensions/api/developer_private/developer_private_api_unittest.cc

 // Copyright 2015 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 "base/files/file_util.h"
 #include "chrome/browser/extensions/api/developer_private/developer_private_api.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_base.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/test_extension_dir.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/host_desktop.h"
+#include "chrome/common/extensions/api/developer_private.h"
 #include "chrome/test/base/test_browser_window.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/test_extension_registry_observer.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/test_util.h"
 
 namespace extensions {
@@ skipping 10 matching lines @@
 
   // Loads an unpacked extension that is backed by a real directory, allowing
   // it to be reloaded.
   const Extension* LoadUnpackedExtension();
 
   // Tests a developer private function that sets an extension pref.
   void TestExtensionPrefSetting(
       UIThreadExtensionFunction* (*create_function)(),
       bool (*has_pref)(const std::string&, content::BrowserContext*));
 
+  testing::AssertionResult TestPackExtensionFunction(
+      const base::ListValue& args,
+      api::developer_private::PackStatus expected_status,
+      int expected_flags);
+
   Browser* browser() { return browser_.get(); }
 
  private:
   // ExtensionServiceTestBase:
   void SetUp() override;
   void TearDown() override;
 
   // The browser (and accompanying window).
   scoped_ptr<TestBrowserWindow> browser_window_;
   scoped_ptr<Browser> browser_;
@@ skipping 71 matching lines @@
   EXPECT_TRUE(has_pref(extension_id, profile()));
 
   base::ListValue disable_args;
   disable_args.AppendString(extension_id);
   disable_args.AppendBoolean(false);
   function = create_function();
   EXPECT_TRUE(RunFunction(function, disable_args));
   EXPECT_FALSE(has_pref(extension_id, profile()));
 }
 
+testing::AssertionResult DeveloperPrivateApiUnitTest::TestPackExtensionFunction(
+    const base::ListValue& args,
+    api::developer_private::PackStatus expected_status,
+    int expected_flags) {
+  scoped_refptr<UIThreadExtensionFunction> function(
+      new api::DeveloperPrivatePackDirectoryFunction());
+  if (!RunFunction(function, args))
+    return testing::AssertionFailure() << "Could not run function.";
+
+  // Extract the result. We don't have to test this here, since it's verified as
+  // part of the general extension api system.
+  const base::Value* response_value = nullptr;
+  CHECK(function->GetResultList()->Get(0u, &response_value));
+  scoped_ptr<api::developer_private::PackDirectoryResponse> response =
+      api::developer_private::PackDirectoryResponse::FromValue(*response_value);
+  CHECK(response);
+
+  if (response->status != expected_status) {
+    return testing::AssertionFailure() << "Expected status: " <<
+        expected_status << ", found status: " << response->status <<
+        ", message: " << response->message;
+  }
+
+  if (response->override_flags != expected_flags) {
+    return testing::AssertionFailure() << "Expected flags: " <<
+        expected_flags << ", found flags: " << response->override_flags;
+  }
+
+  return testing::AssertionSuccess();
+}
+
 void DeveloperPrivateApiUnitTest::SetUp() {
   ExtensionServiceTestBase::SetUp();
   InitializeEmptyExtensionService();
 
   browser_window_.reset(new TestBrowserWindow());
   Browser::CreateParams params(profile(), chrome::HOST_DESKTOP_TYPE_NATIVE);
   params.type = Browser::TYPE_TABBED;
   params.window = browser_window_.get();
   browser_.reset(new Browser(params));
 }
@@ skipping 41 matching lines @@
     return static_cast<UIThreadExtensionFunction*>(
         new api::DeveloperPrivateAllowFileAccessFunction());
   };
   auto has_pref = [](const std::string& extension_id,
                      content::BrowserContext* browser_context) {
     return util::AllowFileAccess(extension_id, browser_context);
   };
   TestExtensionPrefSetting(+create_function, +has_pref);
 }
 
+TEST_F(DeveloperPrivateApiUnitTest, DeveloperPrivatePackFunction) {
+  ResetThreadBundle(content::TestBrowserThreadBundle::DEFAULT);
+
+  base::FilePath root_path = data_dir().AppendASCII("good_unpacked");
+  base::FilePath crx_path = data_dir().AppendASCII("good_unpacked.crx");
+  base::FilePath pem_path = data_dir().AppendASCII("good_unpacked.pem");
+
+  // First, test a directory that should pack properly.
+  base::ListValue pack_args;
+  pack_args.AppendString(root_path.AsUTF8Unsafe());
+  EXPECT_TRUE(TestPackExtensionFunction(
+      pack_args, api::developer_private::PACK_STATUS_SUCCESS, 0));
+
+  // Should have created crx file and pem file.
+  EXPECT_TRUE(base::PathExists(crx_path));
+  EXPECT_TRUE(base::PathExists(pem_path));
+
+  // Deliberately don't cleanup the files, and append the pem path.
+  pack_args.AppendString(pem_path.AsUTF8Unsafe());
+
+  // Try to pack again - we should get a warning abot overwriting the crx.
+  EXPECT_TRUE(TestPackExtensionFunction(
+      pack_args,
+      api::developer_private::PACK_STATUS_WARNING,
+      ExtensionCreator::kOverwriteCRX));
+
+  // Try to pack again, with the overwrite flag; this should succeed.
+  pack_args.AppendInteger(ExtensionCreator::kOverwriteCRX);
+  EXPECT_TRUE(TestPackExtensionFunction(
+      pack_args, api::developer_private::PACK_STATUS_SUCCESS, 0));
+
+  // Try to pack a final time when omitting (an existing) pem file. We should
+  // get an error.
+  base::DeleteFile(crx_path, false);
+  EXPECT_TRUE(pack_args.Remove(1u, nullptr));  // Remove the pem key argument.
+  EXPECT_TRUE(pack_args.Remove(1u, nullptr));  // Remove the flags argument.
+  EXPECT_TRUE(TestPackExtensionFunction(
+      pack_args, api::developer_private::PACK_STATUS_ERROR, 0));
+
+  base::DeleteFile(crx_path, false);
+  base::DeleteFile(pem_path, false);
+}
+
 }  // namespace extensions