Ensure speech synthesis and ChromeVox run outside of normal user sessions.

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 <string>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
@@ skipping 14 matching lines @@
 #include "content/public/browser/plugin_service.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_l10n_util.h"
 #include "extensions/common/file_util.h"
 #include "extensions/common/manifest_constants.h"
 #include "grit/browser_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 
 #if defined(OS_CHROMEOS)
+#include "components/user_manager/user_manager.h"
 #include "grit/keyboard_resources.h"
 #include "ui/file_manager/grit/file_manager_resources.h"
 #include "ui/keyboard/keyboard_util.h"
 #endif
 
 #if defined(GOOGLE_CHROME_BUILD)
 #include "chrome/browser/defaults.h"
 #endif
 
 #if defined(OS_CHROMEOS)
@@ skipping 34 matching lines @@
   DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
   std::string error;
   scoped_ptr<base::DictionaryValue> manifest(
       file_util::LoadManifest(chromevox_path, manifest_filename, &error));
   CHECK(manifest) << error;
   bool localized = extension_l10n_util::LocalizeExtension(
       chromevox_path, manifest.get(), &error);
   CHECK(localized) << error;
   return manifest.Pass();
 }
+
+bool IsNormalSession() {
+  return !base::CommandLine::ForCurrentProcess()->HasSwitch(
+             chromeos::switches::kGuestSession) &&
+         user_manager::UserManager::Get()->IsUserLoggedIn();
+}
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace
 
 ComponentLoader::ComponentExtensionInfo::ComponentExtensionInfo(
     const base::DictionaryValue* manifest, const base::FilePath& directory)
     : manifest(manifest),
       root_directory(directory) {
   if (!root_directory.IsAbsolute()) {
     CHECK(PathService::Get(chrome::DIR_RESOURCES, &root_directory));
@@ skipping 250 matching lines @@
 #if defined(OS_CHROMEOS)
 void ComponentLoader::AddChromeVoxExtension(
     const base::Closure& done_cb) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   base::FilePath resources_path;
   PathService::Get(chrome::DIR_RESOURCES, &resources_path);
 
   base::FilePath chromevox_path =
       resources_path.Append(extension_misc::kChromeVoxExtensionPath);
 
-  const base::CommandLine* command_line =
-      base::CommandLine::ForCurrentProcess();
-  bool is_guest = command_line->HasSwitch(chromeos::switches::kGuestSession);
   const char* manifest_filename =
-      is_guest ? extension_misc::kChromeVoxGuestManifestFilename
-               : extension_misc::kChromeVoxManifestFilename;
+      IsNormalSession() ? extension_misc::kChromeVoxManifestFilename
+                        : extension_misc::kChromeVoxGuestManifestFilename;
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&LoadManifestOnFileThread, chromevox_path, manifest_filename),
       base::Bind(&ComponentLoader::AddChromeVoxExtensionWithManifest,
                  weak_factory_.GetWeakPtr(),
                  chromevox_path,
                  done_cb));
 }
 
 void ComponentLoader::AddChromeVoxExtensionWithManifest(
     const base::FilePath& chromevox_path,
     const base::Closure& done_cb,
     scoped_ptr<base::DictionaryValue> manifest) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   std::string extension_id = Add(manifest.release(), chromevox_path);
   CHECK_EQ(extension_misc::kChromeVoxExtensionId, extension_id);
   if (!done_cb.is_null())
     done_cb.Run();
 }
 
 std::string ComponentLoader::AddChromeOsSpeechSynthesisExtension() {
-  const base::CommandLine* command_line =
-      base::CommandLine::ForCurrentProcess();
-  int idr = command_line->HasSwitch(chromeos::switches::kGuestSession) ?
-      IDR_SPEECH_SYNTHESIS_GUEST_MANIFEST : IDR_SPEECH_SYNTHESIS_MANIFEST;
+  int idr = IsNormalSession() ? IDR_SPEECH_SYNTHESIS_MANIFEST
+                              : IDR_SPEECH_SYNTHESIS_GUEST_MANIFEST;
   std::string id = Add(idr,
       base::FilePath(extension_misc::kSpeechSynthesisExtensionPath));
   EnableFileSystemInGuestMode(id);
   return id;
 }
 #endif
 
 void ComponentLoader::AddWithNameAndDescription(
     int manifest_resource_id,
     const base::FilePath& root_directory,
@@ skipping 236 matching lines @@
 void ComponentLoader::UnloadComponent(ComponentExtensionInfo* component) {
   delete component->manifest;
   if (extension_service_->is_ready()) {
     extension_service_->
         RemoveComponentExtension(component->extension_id);
   }
 }
 
 void ComponentLoader::EnableFileSystemInGuestMode(const std::string& id) {
 #if defined(OS_CHROMEOS)
-  const base::CommandLine* command_line =
-      base::CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(chromeos::switches::kGuestSession)) {
+  if (!IsNormalSession()) {
     // TODO(dpolukhin): Hack to enable HTML5 temporary file system for
     // the extension. Some component extensions don't work without temporary
     // file system access. Make sure temporary file system is enabled in the off
     // the record browser context (as that is the one used in guest session).
     content::BrowserContext* off_the_record_context =
         ExtensionsBrowserClient::Get()->GetOffTheRecordContext(
             browser_context_);
     GURL site = content::SiteInstance::GetSiteForURL(
         off_the_record_context, Extension::GetBaseURLFromExtensionId(id));
     storage::FileSystemContext* file_system_context =
         content::BrowserContext::GetStoragePartitionForSite(
             off_the_record_context, site)->GetFileSystemContext();
     file_system_context->EnableTemporaryFileSystemInIncognito();
   }
 #endif
 }
 
 }  // namespace extensions