Fix AccessibilityExtensionLoader's handling of locked screen

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/lock/webui_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,
-        FileReader::OptionalFileThreadTaskCallback(),  // null callback.
-        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,
     const base::Closure& unload_callback)
     : profile_(nullptr),
       extension_id_(extension_id),
       extension_path_(extension_path),
-      loaded_on_lock_screen_(false),
-      loaded_on_user_screen_(false),
+      loaded_(false),
       unload_callback_(unload_callback),
       weak_ptr_factory_(this) {}
 
 AccessibilityExtensionLoader::~AccessibilityExtensionLoader() {}
 
 void AccessibilityExtensionLoader::SetProfile(
     Profile* profile,
     const base::Closure& done_callback) {
   profile_ = profile;
 
-  if (!loaded_on_user_screen_ && !loaded_on_lock_screen_)
+  if (!loaded_)
     return;
 
   // If the extension was already enabled, but not for this profile, add it
   // to this profile.
   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, done_callback);
+    LoadExtension(profile_, done_callback);
 }
 
 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);
-  }
+
+  if (loaded_)
+    return;
+
+  loaded_ = true;
+  LoadExtension(profile_, done_cb);
 }
 
 void AccessibilityExtensionLoader::Unload() {
-  if (loaded_on_lock_screen_)
-    UnloadFromLockScreen();
-
-  if (loaded_on_user_screen_) {
+  if (loaded_) {
     UnloadExtensionFromProfile(profile_);
-    loaded_on_user_screen_ = false;
+    UnloadExtensionFromProfile(ProfileHelper::GetSigninProfile());
+    loaded_ = false;
   }
 
   profile_ = nullptr;
 
   if (unload_callback_)
     unload_callback_.Run();
 }
 
-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 = nullptr;
-
-  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()
-                    : nullptr,
-                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->web_ui()->GetWebUI();
-    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);
-    }
-  }
-}
-
 //
 // 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()) {

[dmazzoni, 2017/01/09 19:17:19]

init_script_str is unused, now. If it's really not needed, you
can remove the places where it's set. However, I wonder if we
might still need to set "window.INJECTED_AFTER_LOAD = true"
so that Classic can distinguish between the case where it's
enabled dynamically and when a page loads. In particular,
Classic ought to announce when a page loads, but switching
to Classic shouldn't announce the same way a page load does.

Perhaps we could solve this differently by having Classic
query the background page to determine whether it should
announce a page load or not.

-    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