chromeos: Make Chrome app a real app.

chrome/browser/extensions/component_loader.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/component_loader.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/path_service.h"
@@ skipping 17 matching lines @@
 #include "ui/base/resource/resource_bundle.h"
 
 #if defined(OFFICIAL_BUILD)
 #include "chrome/browser/defaults.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/user_manager.h"
 #endif
 
+#if defined(USE_ASH)
+#include "grit/chromium_strings.h"
+#include "ui/base/l10n/l10n_util.h"
+#endif
+
 namespace extensions {
 
 ComponentLoader::ComponentLoader(ExtensionServiceInterface* extension_service,
                                  PrefService* prefs,
                                  PrefService* local_state)
     : prefs_(prefs),
       local_state_(local_state),
       extension_service_(extension_service) {
   pref_change_registrar_.Init(prefs);
 
@@ skipping 41 matching lines @@
     int manifest_resource_id,
     const FilePath& root_directory) {
   std::string manifest_contents =
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           manifest_resource_id,
           ui::SCALE_FACTOR_NONE).as_string();
   return Add(manifest_contents, root_directory);
 }
 
 const Extension* ComponentLoader::Add(
-    std::string& manifest_contents,
+    const std::string& manifest_contents,
     const FilePath& root_directory) {
   // The Value is kept for the lifetime of the ComponentLoader. This is
   // required in case LoadAll() is called again.
   DictionaryValue* manifest = ParseManifest(manifest_contents);
   if (manifest)
     return Add(manifest, root_directory);
   return NULL;
 }
 
 const Extension* ComponentLoader::Add(
@@ skipping 160 matching lines @@
     DictionaryValue* manifest = ParseManifest(manifest_contents);
     if (manifest) {
       std::string name = prefs_->GetString(prefs::kEnterpriseWebStoreName);
       manifest->SetString("app.launch.web_url", enterprise_webstore_url);
       manifest->SetString("name", name);
       Add(manifest, path);
     }
   }
 }
 
+void ComponentLoader::AddChromeApp() {
+#if defined(USE_ASH)
+  std::string manifest_contents =
+      ResourceBundle::GetSharedInstance().GetRawDataResource(
+          IDR_CHROME_APP_MANIFEST,
+          ui::SCALE_FACTOR_NONE).as_string();
+
+  // The Value is kept for the lifetime of the ComponentLoader. This is
+  // required in case LoadAll() is called again.
+  DictionaryValue* manifest = ParseManifest(manifest_contents);
+
+  // Update manifest to use a proper name.
+  manifest->SetString(extension_manifest_keys::kName,
+                      l10n_util::GetStringUTF8(IDS_SHORT_PRODUCT_NAME));
+
+  if (manifest)
+    Add(manifest, FilePath(FILE_PATH_LITERAL("chrome_app")));
+#endif
+}
+
 void ComponentLoader::AddDefaultComponentExtensions() {
 #if defined(OS_CHROMEOS)
   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kGuestSession))
     Add(IDR_BOOKMARKS_MANIFEST,
         FilePath(FILE_PATH_LITERAL("bookmark_manager")));
 #else
   Add(IDR_BOOKMARKS_MANIFEST, FilePath(FILE_PATH_LITERAL("bookmark_manager")));
 #endif
 
 #if defined(OS_CHROMEOS)
@@ skipping 49 matching lines @@
         .AppendASCII(extension_misc::kChromeVoxDirectoryName);
     Add(IDR_CHROMEVOX_MANIFEST, path);
   }
 #endif
 
   // If a URL for the enterprise webstore has been specified, load the
   // component extension. This extension might also be loaded later, because
   // it is specified by policy, and on ChromeOS policies are loaded after
   // the browser process has started.
   AddOrReloadEnterpriseWebStore();
+
+#if defined(USE_ASH)
+  AddChromeApp();
+#endif
 }
 
 void ComponentLoader::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_PREF_CHANGED) {
     const std::string* name =
         content::Details<const std::string>(details).ptr();
     if (*name == prefs::kEnterpriseWebStoreURL)
       AddOrReloadEnterpriseWebStore();
     else
       NOTREACHED();
   } else {
     NOTREACHED();
   }
 }
 
 // static
 void ComponentLoader::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterStringPref(prefs::kEnterpriseWebStoreURL,
                             std::string() /* default_value */,
                             PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(prefs::kEnterpriseWebStoreName,
                             std::string() /* default_value */,
                             PrefService::UNSYNCABLE_PREF);
 }
 
 }  // namespace extensions