Instead of marking all default apps as bookmark apps, allow it to be specified per-app.

chrome/browser/extensions/external_extension_provider_impl.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/external_extension_provider_impl.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
@@ skipping 31 matching lines @@
 using content::BrowserThread;
 
 // Constants for keeping track of extension preferences in a dictionary.
 const char ExternalExtensionProviderImpl::kExternalCrx[] = "external_crx";
 const char ExternalExtensionProviderImpl::kExternalVersion[] =
     "external_version";
 const char ExternalExtensionProviderImpl::kExternalUpdateUrl[] =
     "external_update_url";
 const char ExternalExtensionProviderImpl::kSupportedLocales[] =
     "supported_locales";
+const char ExternalExtensionProviderImpl::kIsBookmarkApp[] =
+    "is_bookmark_app";
 
 ExternalExtensionProviderImpl::ExternalExtensionProviderImpl(
     VisitorInterface* service,
     ExternalExtensionLoader* loader,
     Extension::Location crx_location,
     Extension::Location download_location,
     int creation_flags)
   : crx_location_(crx_location),
     download_location_(download_location),
     service_(service),
@@ skipping 99 matching lines @@
 
       if (!locale_supported) {
         unsupported_extensions.insert(extension_id);
         LOG(INFO) << "Skip installing (or uninstall) external extension: "
                   << extension_id << " because the extension doesn't support "
                   << "the browser locale.";
         continue;
       }
     }
 
+    int creation_flags = creation_flags_;
+    bool is_bookmark_app;
+    if (extension->GetBoolean(kIsBookmarkApp, &is_bookmark_app) &&
+        is_bookmark_app) {
+      creation_flags |= Extension::FROM_BOOKMARK;
+    }
+
     if (has_external_crx) {
       if (crx_location_ == Extension::INVALID) {
         LOG(WARNING) << "This provider does not support installing external "
                      << "extensions from crx files.";
         continue;
       }
       if (external_crx.find(FilePath::kParentDirectory) !=
           base::StringPiece::npos) {
         LOG(WARNING) << "Path traversal not allowed in path: "
                      << external_crx.c_str();
@@ skipping 15 matching lines @@
 
       scoped_ptr<Version> version;
       version.reset(Version::GetVersionFromString(external_version));
       if (!version.get()) {
         LOG(WARNING) << "Malformed extension dictionary for extension: "
                      << extension_id.c_str() << ".  Invalid version string \""
                      << external_version << "\".";
         continue;
       }
       service_->OnExternalExtensionFileFound(extension_id, version.get(), path,
-                                             crx_location_, creation_flags_,
+                                             crx_location_, creation_flags,
                                              auto_acknowledge_);
     } else { // if (has_external_update_url)
       CHECK(has_external_update_url);  // Checking of keys above ensures this.
       if (download_location_ == Extension::INVALID) {
         LOG(WARNING) << "This provider does not support installing external "
                      << "extensions from update URLs.";
         continue;
       }
       GURL update_url(external_update_url);
       if (!update_url.is_valid()) {
@@ skipping 19 matching lines @@
 }
 
 void ExternalExtensionProviderImpl::ServiceShutdown() {
   service_ = NULL;
 }
 
 bool ExternalExtensionProviderImpl::IsReady() const {
   return ready_;
 }
 
-int ExternalExtensionProviderImpl::GetCreationFlags() const {
-  return creation_flags_;
-}
-
 bool ExternalExtensionProviderImpl::HasExtension(
     const std::string& id) const {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(prefs_.get());
   CHECK(ready_);
   return prefs_->HasKey(id);
 }
 
 bool ExternalExtensionProviderImpl::GetExtensionDetails(
     const std::string& id, Extension::Location* location,
@@ skipping 112 matching lines @@
   provider_list->push_back(
       linked_ptr<ExternalExtensionProviderInterface>(
           new default_apps::Provider(
               profile,
               service,
               new ExternalPrefExtensionLoader(
                   chrome::DIR_DEFAULT_APPS,
                   ExternalPrefExtensionLoader::NONE),
               Extension::EXTERNAL_PREF,
               Extension::INVALID,
-              Extension::FROM_BOOKMARK)));
+              Extension::FROM_WEBSTORE)));
 #endif
 
 #if defined(OS_CHROMEOS)
   chromeos::UserManager* user_manager = chromeos::UserManager::Get();
   policy::BrowserPolicyConnector* connector =
       g_browser_process->browser_policy_connector();
   if (user_manager && user_manager->IsLoggedInAsDemoUser() &&
       connector->GetDeviceMode() == policy::DEVICE_MODE_KIOSK &&
       connector->GetAppPackUpdater()) {
     provider_list->push_back(
         linked_ptr<ExternalExtensionProviderInterface>(
           new ExternalExtensionProviderImpl(
               service,
               connector->GetAppPackUpdater()->CreateExternalExtensionLoader(),
               Extension::EXTERNAL_PREF,
               Extension::INVALID,
               Extension::NO_FLAGS)));
   }
 #endif
 }