Check the IME component extension's availability on linux_chromeos, so that system fallback VK can …

chrome/browser/chromeos/input_method/component_extension_ime_manager_impl.cc

 // Copyright 2013 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/chromeos/input_method/component_extension_ime_manager_impl.h"
 
 #include <algorithm>
 
 #include "base/file_util.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "chrome/browser/extensions/component_loader.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/grit/browser_resources.h"
 #include "chrome/grit/generated_resources.h"
 #include "chromeos/ime/extension_ime_util.h"
+#include "content/public/browser/browser_thread.h"
 #include "extensions/browser/extension_system.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 "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 
 namespace chromeos {
 
 namespace {
 
 struct WhitelistedComponentExtensionIME {
   const char* id;
@@ skipping 193 matching lines @@
 };
 
 const char kImePathKeyName[] = "ime_path";
 
 extensions::ComponentLoader* GetComponentLoader(Profile* profile) {
   extensions::ExtensionSystem* extension_system =
       extensions::ExtensionSystem::Get(profile);
   ExtensionService* extension_service = extension_system->extension_service();
   return extension_service->component_loader();
 }
+
+void CheckFilePath(const base::FilePath* file_path, bool* result) {
+  *result = base::PathExists(*file_path);
+}
+
+void OnFilePathChecked(Profile* profile,
+                       const std::string* manifest,
+                       const base::FilePath* file_path,
+                       bool* result) {
+  if (*result)
+    GetComponentLoader(profile)->Add(*manifest, *file_path);
+  else
+    LOG(ERROR) << "IME extension file path not exists: " << file_path->value();
+}
+
 }  // namespace
 
-ComponentExtensionIMEManagerImpl::ComponentExtensionIMEManagerImpl()
-    : weak_ptr_factory_(this) {
+ComponentExtensionIMEManagerImpl::ComponentExtensionIMEManagerImpl() {
   ReadComponentExtensionsInfo(&component_extension_list_);
 }
 
 ComponentExtensionIMEManagerImpl::~ComponentExtensionIMEManagerImpl() {
 }
 
 std::vector<ComponentExtensionIME> ComponentExtensionIMEManagerImpl::ListIME() {
   return component_extension_list_;
 }
 
 bool ComponentExtensionIMEManagerImpl::Load(Profile* profile,
                                             const std::string& extension_id,
                                             const std::string& manifest,
                                             const base::FilePath& file_path) {
   extensions::ExtensionSystem* extension_system =
       extensions::ExtensionSystem::Get(profile);
   ExtensionService* extension_service = extension_system->extension_service();
   if (extension_service->GetExtensionById(extension_id, false))
     return false;
+
+  // If current environment is linux_chromeos, check the existence of file path
+  // to avoid unnecessary extension loading and InputMethodEngine creation, so
+  // that the virtual keyboard web content url won't be override by IME
+  // component extensions.
+  if (!base::SysInfo::IsRunningOnChromeOS()) {
+    bool* exists = new bool;
+    *exists = false;
+    base::FilePath* copied_file_path = new base::FilePath(file_path);
+
+    content::BrowserThread::PostTaskAndReply(

[Seigo Nonaka, 2014/08/25 02:01:08]

Probably, you may want to use PostTaskAndReplyWIthResult function.

[Shu Chen, 2014/08/25 02:31:08]

Done.

+        content::BrowserThread::FILE,
+        FROM_HERE,
+        base::Bind(&CheckFilePath,
+                   base::Unretained(copied_file_path),
+                   base::Unretained(exists)),
+        base::Bind(&OnFilePathChecked,
+                   base::Unretained(profile),
+                   base::Owned(new std::string(manifest)),
+                   base::Owned(copied_file_path),
+                   base::Owned(exists)));
+    return false;

[Seigo Nonaka, 2014/08/25 02:01:08]

is it okay to return false here? Probably at least need to add comment to
header.

[Shu Chen, 2014/08/25 02:31:08]

Done. I've made the return type as void.

+  }
   const std::string loaded_extension_id =
       GetComponentLoader(profile)->Add(manifest, file_path);
   DCHECK_EQ(loaded_extension_id, extension_id);
   return true;
 }
 
 void ComponentExtensionIMEManagerImpl::Unload(Profile* profile,
                                               const std::string& extension_id,
                                               const base::FilePath& file_path) {
   // Remove(extension_id) does nothing when the extension has already been
@@ skipping 170 matching lines @@
 
       ComponentExtensionEngine engine;
       ReadEngineComponent(component_ime, *dictionary, &engine);
       component_ime.engines.push_back(engine);
     }
     out_imes->push_back(component_ime);
   }
 }
 
 }  // namespace chromeos