Factor the extension loading code out of AccessibilityManager

chrome/browser/chromeos/accessibility/accessibility_extension_loader.cc

+// Copyright 2016 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/accessibility/accessibility_extension_loader.h"
+
+#include "base/callback.h"
+#include "base/callback_helpers.h"
+#include "base/path_service.h"
+#include "chrome/browser/chromeos/login/lock/screen_locker.h"
+#include "chrome/browser/chromeos/login/ui/login_display_host.h"
+#include "chrome/browser/chromeos/login/ui/webui_login_view.h"
+#include "chrome/browser/chromeos/profiles/profile_helper.h"
+#include "chrome/browser/extensions/component_loader.h"
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/tab_helper.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/extensions/extension_constants.h"
+#include "chrome/common/extensions/manifest_handlers/content_scripts_handler.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/web_contents.h"
+#include "extensions/browser/extension_api_frame_id_map.h"
+#include "extensions/browser/extension_registry.h"
+#include "extensions/browser/extension_system.h"
+#include "extensions/browser/file_reader.h"
+#include "extensions/browser/script_executor.h"
+#include "extensions/common/extension.h"
+#include "extensions/common/extension_messages.h"
+#include "extensions/common/extension_resource.h"
+
+namespace chromeos {
+
+namespace {
+
+// Uses the ScriptExecutor associated with the given |render_view_host| to
+// execute the given |code|.
+void ExecuteScriptHelper(content::RenderViewHost* render_view_host,
+                         const std::string& code,
+                         const std::string& extension_id) {
+  content::WebContents* web_contents =
+      content::WebContents::FromRenderViewHost(render_view_host);
+  if (!web_contents)
+    return;
+  if (!extensions::TabHelper::FromWebContents(web_contents))
+    extensions::TabHelper::CreateForWebContents(web_contents);
+  extensions::TabHelper::FromWebContents(web_contents)
+      ->script_executor()
+      ->ExecuteScript(HostID(HostID::EXTENSIONS, extension_id),
+                      extensions::ScriptExecutor::JAVASCRIPT, code,
+                      extensions::ScriptExecutor::INCLUDE_SUB_FRAMES,
+                      extensions::ExtensionApiFrameIdMap::kTopFrameId,
+                      extensions::ScriptExecutor::DONT_MATCH_ABOUT_BLANK,
+                      extensions::UserScript::DOCUMENT_IDLE,
+                      extensions::ScriptExecutor::ISOLATED_WORLD,
+                      extensions::ScriptExecutor::DEFAULT_PROCESS,
+                      GURL(),  // No webview src.
+                      GURL(),  // No file url.
+                      false,   // Not user gesture.
+                      extensions::ScriptExecutor::NO_RESULT,
+                      extensions::ScriptExecutor::ExecuteScriptCallback());
+}
+
+// Helper class that directly loads an extension's content scripts into
+// all of the frames corresponding to a given RenderViewHost.
+class ContentScriptLoader {
+ public:
+  // Initialize the ContentScriptLoader with the ID of the extension
+  // and the RenderViewHost where the scripts should be loaded.
+  ContentScriptLoader(const std::string& extension_id,
+                      int render_process_id,
+                      int render_view_id)
+      : extension_id_(extension_id),
+        render_process_id_(render_process_id),
+        render_view_id_(render_view_id) {}
+
+  // Call this once with the ExtensionResource corresponding to each
+  // content script to be loaded.
+  void AppendScript(extensions::ExtensionResource resource) {
+    resources_.push(resource);
+  }
+
+  // Finally, call this method once to fetch all of the resources and
+  // load them. This method will delete this object when done.
+  void Run() {
+    if (resources_.empty()) {
+      delete this;
+      return;
+    }
+
+    extensions::ExtensionResource resource = resources_.front();
+    resources_.pop();
+    scoped_refptr<FileReader> reader(
+        new FileReader(resource, base::Bind(&ContentScriptLoader::OnFileLoaded,
+                                            base::Unretained(this))));
+    reader->Start();
+  }
+
+ private:
+  void OnFileLoaded(bool success, std::unique_ptr<std::string> data) {
+    if (success) {
+      content::RenderViewHost* render_view_host =
+          content::RenderViewHost::FromID(render_process_id_, render_view_id_);
+      if (render_view_host)
+        ExecuteScriptHelper(render_view_host, *data, extension_id_);
+    }
+    Run();
+  }
+
+  std::string extension_id_;
+  int render_process_id_;
+  int render_view_id_;
+  std::queue<extensions::ExtensionResource> resources_;
+};
+
+}  // namespace
+
+AccessibilityExtensionLoader::AccessibilityExtensionLoader(
+    const std::string& extension_id,
+    const base::FilePath& extension_path)
+    : profile_(nullptr),

[David Tseng, 2016/09/08 20:39:31]

nit: indent

[dmazzoni, 2016/09/08 21:00:55]

git cl format is happy with this...where did you expect the indent to be?

[David Tseng, 2016/09/08 21:18:42]

+4 since it's a continuation of the previous line.

[dmazzoni, 2016/09/13 23:03:19]

The colon to begin initializers for a constructor is supposed to be at +4 from
the constructor definition, so this is right. It's not considered to be a
continuation of the argument list. The rest of the initializers are allowed to
line up with the first one.

+      extension_id_(extension_id),
+      extension_path_(extension_path),
+      loaded_on_lock_screen_(false),
+      loaded_on_user_screen_(false),
+      weak_ptr_factory_(this) {}
+
+AccessibilityExtensionLoader::~AccessibilityExtensionLoader() {}
+
+void AccessibilityExtensionLoader::SetProfile(Profile* profile) {
+  profile_ = profile;

[David Tseng, 2016/09/08 20:39:31]

This block has similarity index with
AccessibilityManager::UpdateSpokenFeedbackFromPref. One change, perhaps I'm not
seeing, is:
- AccessibilityManager::UpdateSpokenFeedbackFromPref in this change calls
AEL::Load(), but never calls AEL::SetProfile
- AccessibilityManager::UpdateSpokenFeedbackFromPref used to check that
ChromeVox wasn't already loaded on the profile w/ ComponentLoader, similar to
the check below, but that never occurs now I think.

[dmazzoni, 2016/09/08 21:00:55]

Good question. There are a few scenarios.

1. If ChromeVox was disabled but it's now being enabled,
UpdateSpokenFeedbackFromPref calls AEL::Load and that sets
the profile.
2. If ChromeVox was enabled but the profile is changed,
AccessibilityManager::SetProfile calls AEL::SetProfile,
and that catches the case where it was loaded, but just not
in this profile. Previously we handled that case in
UpdateSpokenFeedbackFromPref, it's true - but that's just
because we knew that UpdateSpokenFeedbackFromPref would be
called when SetProfile is called.

So I think this should cover the important cases.

[David Tseng, 2016/09/08 21:18:42]

because we knew that UpdateSpokenFeedbackFromPref would be
called when SetProfile is called.

UpdateSpokenFeedbackFromPref gets called by the PrefChangeRegistrar -- I haven't
looked at when that triggers.

In any case, if you're sure this works, then this seems fine, but if you want to
call SetProfile from UpdateSpokenFeedbackFromPref to try and maintain the
mechanical part of this change then apply the a change to remove it to be safe,
that would probably be better.

[dmazzoni, 2016/09/13 23:03:19]

Makes sense, I added a call to SetProfile.

+
+  if (!loaded_on_user_screen_ && !loaded_on_lock_screen_)
+    return;
+
+  // If the extension was already enabled, but not for this profile,
+  // add it to this profile.

[David Tseng, 2016/09/08 20:39:31]

nit: more room above

[dmazzoni, 2016/09/08 21:00:55]

done

+  auto* extension_service =
+      extensions::ExtensionSystem::Get(profile_)->extension_service();
+  auto* component_loader = extension_service->component_loader();
+  if (!component_loader->Exists(extension_id_))
+    LoadExtension(profile_, nullptr, base::Closure());
+}
+
+void AccessibilityExtensionLoader::Load(Profile* profile,
+                                        const std::string& init_script_str,
+                                        const base::Closure& done_cb) {
+  profile_ = profile;
+  init_script_str_ = init_script_str;
+  ScreenLocker* screen_locker = ScreenLocker::default_screen_locker();
+  if (screen_locker && screen_locker->locked()) {
+    // If on the lock screen, loads only to the lock screen as for
+    // now. On unlock, it will be loaded to the user screen.
+    // (see. AccessibilityExtensionLoader::Observe())
+    LoadToLockScreen(done_cb);
+  } else {
+    LoadToUserScreen(done_cb);
+  }
+}
+
+void AccessibilityExtensionLoader::Unload() {
+  if (loaded_on_lock_screen_)
+    UnloadFromLockScreen();
+
+  if (loaded_on_user_screen_) {
+    UnloadExtensionFromProfile(profile_);
+    loaded_on_user_screen_ = false;
+  }
+
+  profile_ = nullptr;
+}
+
+void AccessibilityExtensionLoader::LoadToUserScreen(
+    const base::Closure& done_cb) {
+  if (loaded_on_user_screen_)
+    return;
+
+  // Determine whether an OOBE screen is currently being shown. If so,
+  // the extension will be injected directly into that screen.
+  content::WebUI* login_web_ui = NULL;
+
+  if (ProfileHelper::IsSigninProfile(profile_)) {
+    LoginDisplayHost* login_display_host = LoginDisplayHost::default_host();
+    if (login_display_host) {
+      WebUILoginView* web_ui_login_view =
+          login_display_host->GetWebUILoginView();
+      if (web_ui_login_view)
+        login_web_ui = web_ui_login_view->GetWebUI();
+    }
+
+    // Lock screen uses the signin progile.
+    loaded_on_lock_screen_ = true;
+  }
+
+  loaded_on_user_screen_ = true;
+  LoadExtension(
+      profile_,
+      login_web_ui ? login_web_ui->GetWebContents()->GetRenderViewHost() : NULL,
+      done_cb);
+}
+
+void AccessibilityExtensionLoader::LoadToLockScreen(
+    const base::Closure& done_cb) {
+  if (loaded_on_lock_screen_)
+    return;
+
+  ScreenLocker* screen_locker = ScreenLocker::default_screen_locker();
+  if (screen_locker && screen_locker->locked()) {
+    content::WebUI* lock_web_ui = screen_locker->GetAssociatedWebUI();
+    if (lock_web_ui) {
+      Profile* profile = Profile::FromWebUI(lock_web_ui);
+      loaded_on_lock_screen_ = true;
+      LoadExtension(profile, lock_web_ui->GetWebContents()->GetRenderViewHost(),
+                    done_cb);
+    }
+  }
+}
+
+void AccessibilityExtensionLoader::InjectContentScript(
+    content::RenderViewHost* render_view_host) {
+  ExtensionService* extension_service =
+      extensions::ExtensionSystem::Get(profile_)->extension_service();
+  InjectContentScriptAndCallback(
+      extension_service, render_view_host->GetProcess()->GetID(),
+      render_view_host->GetRoutingID(), base::Closure());
+}
+
+//
+// private
+//
+
+void AccessibilityExtensionLoader::UnloadExtensionFromProfile(
+    Profile* profile) {
+  ExtensionService* extension_service =
+      extensions::ExtensionSystem::Get(profile)->extension_service();
+  extension_service->component_loader()->Remove(extension_path_);
+}
+
+void AccessibilityExtensionLoader::UnloadFromLockScreen() {
+  // Lock screen uses the signin progile.
+  Profile* signin_profile = ProfileHelper::GetSigninProfile();
+  UnloadExtensionFromProfile(signin_profile);
+  loaded_on_lock_screen_ = false;
+}
+
+void AccessibilityExtensionLoader::InjectContentScriptAndCallback(
+    ExtensionService* extension_service,
+    int render_process_id,
+    int render_view_id,
+    const base::Closure& done_cb) {
+  // Make sure to always run |done_cb|.  The extension was loaded even
+  // if we end up not injecting into this particular render view.
+  base::ScopedClosureRunner done_runner(done_cb);
+  content::RenderViewHost* render_view_host =
+      content::RenderViewHost::FromID(render_process_id, render_view_id);
+  if (!render_view_host)
+    return;
+  const content::WebContents* web_contents =
+      content::WebContents::FromRenderViewHost(render_view_host);
+  GURL content_url;
+  if (web_contents)
+    content_url = web_contents->GetLastCommittedURL();
+  const extensions::Extension* extension =
+      extensions::ExtensionRegistry::Get(extension_service->profile())
+          ->enabled_extensions()
+          .GetByID(extension_id_);
+
+  if (!init_script_str_.empty()) {
+    ExecuteScriptHelper(render_view_host, init_script_str_, extension->id());
+  }
+
+  // Inject the content scripts.
+  ContentScriptLoader* loader = new ContentScriptLoader(
+      extension->id(), render_view_host->GetProcess()->GetID(),
+      render_view_host->GetRoutingID());
+
+  const extensions::UserScriptList& content_scripts =
+      extensions::ContentScriptsInfo::GetContentScripts(extension);
+  for (const std::unique_ptr<extensions::UserScript>& script :
+       content_scripts) {
+    if (web_contents && !script->MatchesURL(content_url))
+      continue;
+    for (const std::unique_ptr<extensions::UserScript::File>& file :
+         script->js_scripts()) {
+      extensions::ExtensionResource resource =
+          extension->GetResource(file->relative_path());
+      loader->AppendScript(resource);
+    }
+  }
+  loader->Run();  // It cleans itself up when done.
+}
+
+void AccessibilityExtensionLoader::LoadExtension(
+    Profile* profile,
+    content::RenderViewHost* render_view_host,
+    base::Closure done_cb) {
+  ExtensionService* extension_service =
+      extensions::ExtensionSystem::Get(profile)->extension_service();
+  if (render_view_host) {
+    // Wrap the passed in callback to inject the content script.
+    done_cb = base::Bind(
+        &AccessibilityExtensionLoader::InjectContentScriptAndCallback,
+        weak_ptr_factory_.GetWeakPtr(), extension_service,
+        render_view_host->GetProcess()->GetID(),
+        render_view_host->GetRoutingID(), done_cb);
+  }
+
+  extension_service->component_loader()->AddComponentFromDir(
+      extension_path_, extension_id_.c_str(), done_cb);
+}
+
+}  // namespace chromeos