Make WebUI webview content script work with incognito.

extensions/browser/web_ui_user_script_loader.cc

 // Copyright 2015 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 "extensions/browser/web_ui_user_script_loader.h"
 
 #include "base/bind.h"
 #include "base/pickle.h"
 #include "base/strings/string_util.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/content_verifier.h"
+#include "extensions/browser/extensions_browser_client.h"
 
 namespace {
 using LoadScriptsCallback =
     base::Callback<void(scoped_ptr<extensions::UserScriptList>,
                         scoped_ptr<base::SharedMemory>)>;
 
 void SerializeOnFileThread(scoped_ptr<extensions::UserScriptList> user_scripts,
                            LoadScriptsCallback callback) {
   scoped_ptr<base::SharedMemory> memory =
       extensions::UserScriptLoader::Serialize(*user_scripts);
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(callback, base::Passed(&user_scripts), base::Passed(&memory)));
 }
 
 }  // namespace
 
 struct WebUIUserScriptLoader::UserScriptRenderInfo {
   int render_process_id;
   int render_view_id;
+  bool is_incognito;
 
-  UserScriptRenderInfo() : render_process_id(-1), render_view_id(-1) {}
+  UserScriptRenderInfo()
+      : render_process_id(-1),
+        render_view_id(-1),
+        is_incognito(false) {}
 
-  UserScriptRenderInfo(int render_process_id, int render_view_id)
-      : render_process_id(render_process_id), render_view_id(render_view_id) {}
+  UserScriptRenderInfo(int render_process_id,
+                       int render_view_id,
+                       bool is_incognito)
+      : render_process_id(render_process_id),
+        render_view_id(render_view_id),
+        is_incognito(is_incognito) {}
 
   bool operator<(const UserScriptRenderInfo& other) {
     if (render_process_id != other.render_process_id)
       return render_process_id < other.render_process_id;
 
     if (render_view_id != other.render_view_id)
       return render_view_id < other.render_view_id;
 
+    if (is_incognito != other.is_incognito)
+      return is_incognito == false;
+
     return false;
   }
 };
 
 WebUIUserScriptLoader::WebUIUserScriptLoader(
     content::BrowserContext* browser_context,
     const HostID& host_id)
     : UserScriptLoader(browser_context, host_id),
       complete_fetchers_(0),
       user_scripts_cache_(nullptr),
       weak_factory_(this) {
   SetReady(true);
 }
 
 WebUIUserScriptLoader::~WebUIUserScriptLoader() {
 }
 
 void WebUIUserScriptLoader::AddScripts(
     const std::set<extensions::UserScript>& scripts,
     int render_process_id,
-    int render_view_id) {
-  UserScriptRenderInfo info(render_process_id, render_view_id);
+    int render_view_id,
+    bool is_incognito) {
+  UserScriptRenderInfo info(render_process_id, render_view_id, is_incognito);
   for (const extensions::UserScript& script : scripts) {
     script_render_info_map_.insert(
         std::pair<int, UserScriptRenderInfo>(script.id(), info));
   }
 
   extensions::UserScriptLoader::AddScripts(scripts);
 }
 
 void WebUIUserScriptLoader::LoadScripts(
     scoped_ptr<extensions::UserScriptList> user_scripts,
     const std::set<HostID>& changed_hosts,
     const std::set<int>& added_script_ids) {
   user_scripts_cache_.swap(user_scripts);
 
   // The total number of the tasks is used to trace whether all the fetches
   // are complete. Therefore, we store all the fetcher pointers in |fetchers_|
   // before we get theis number. Once we get the total number, start each
   // fetch tasks.
   complete_fetchers_ = 0;
 
   for (extensions::UserScript& script : *user_scripts_cache_) {
     if (added_script_ids.count(script.id()) == 0)
       continue;
 
     auto iter = script_render_info_map_.find(script.id());
     DCHECK(iter != script_render_info_map_.end());
     int render_process_id = iter->second.render_process_id;
     int render_view_id = iter->second.render_view_id;
 
-    CreateWebUIURLFetchers(&script.js_scripts(), render_process_id,
-                           render_view_id);
-    CreateWebUIURLFetchers(&script.css_scripts(), render_process_id,
-                           render_view_id);
+    content::BrowserContext* browser_context = iter->second.is_incognito

[Devlin, 2015/04/23 17:53:47]

Can't we basically replace this whole patch with
content::BrowserContext* browser_context =
    content::RenderProcessHost::FromID(render_process_id)->GetBrowserContext();
?

+        ? extensions::ExtensionsBrowserClient::Get()->GetOffTheRecordContext(
+            UserScriptLoader::browser_context())
+        : UserScriptLoader::browser_context();
+    DCHECK(browser_context);
+
+    CreateWebUIURLFetchers(&script.js_scripts(), browser_context,
+                           render_process_id, render_view_id);
+    CreateWebUIURLFetchers(&script.css_scripts(), browser_context,
+                           render_process_id, render_view_id);
 
     script_render_info_map_.erase(script.id());
   }
 
   // If no fetch is needed, call OnWebUIURLFetchComplete directly.
   if (fetchers_.empty()) {
     OnWebUIURLFetchComplete();
     return;
   }
   for (auto fetcher : fetchers_)
     fetcher->Start();
 }
 
 void WebUIUserScriptLoader::CreateWebUIURLFetchers(
     extensions::UserScript::FileList* script_files,
+    content::BrowserContext* browser_context,
     int render_process_id,
     int render_view_id) {
   for (extensions::UserScript::File& file : *script_files) {
     if (file.GetContent().empty()) {
       // The WebUIUserScriptLoader owns these WebUIURLFetchers. Once the
       // loader is destroyed, all the fetchers will be destroyed. Therefore,
       // we are sure it is safe to use base::Unretained(this) here.
       scoped_ptr<WebUIURLFetcher> fetcher(new WebUIURLFetcher(
-          browser_context(), render_process_id, render_view_id, file.url(),
+          browser_context, render_process_id, render_view_id, file.url(),
           base::Bind(&WebUIUserScriptLoader::OnSingleWebUIURLFetchComplete,
                      base::Unretained(this), &file)));
       fetchers_.push_back(fetcher.release());
     }
   }
 }
 
 void WebUIUserScriptLoader::OnSingleWebUIURLFetchComplete(
     extensions::UserScript::File* script_file,
     bool success,
@@ skipping 15 matching lines @@
   }
 }
 
 void WebUIUserScriptLoader::OnWebUIURLFetchComplete() {
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE, FROM_HERE,
       base::Bind(&SerializeOnFileThread, base::Passed(&user_scripts_cache_),
                  base::Bind(&WebUIUserScriptLoader::OnScriptsLoaded,
                             weak_factory_.GetWeakPtr())));
 }