Fix callsites to URLRequestContext::CopyFrom

chrome/browser/profiles/profile_browsertest.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/profiles/profile.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 20 matching lines @@
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/bookmarks/browser/startup_task_runner_service.h"
 #include "components/prefs/pref_service.h"
 #include "components/version_info/version_info.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/test/test_utils.h"
+#include "extensions/browser/extension_registry.h"
+#include "extensions/common/extension.h"
+#include "extensions/common/extension_builder.h"
+#include "extensions/common/value_builder.h"
 #include "net/base/net_errors.h"
 #include "net/test/url_request/url_request_failed_job.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
@@ skipping 363 matching lines @@
 
     // Setting back to a crashed value should work.
     profile->SetExitType(Profile::EXIT_CRASHED);
     std::string final_value(prefs->GetString(prefs::kSessionExitType));
     EXPECT_EQ(crash_value, final_value);
   }
 
   FlushIoTaskRunnerAndSpinThreads();
 }
 
+namespace {
+
+scoped_refptr<const extensions::Extension> BuildTestApp(Profile* profile) {
+  scoped_refptr<const extensions::Extension> app;
+  app =
+      extensions::ExtensionBuilder()
+          .SetManifest(
+              extensions::DictionaryBuilder()
+                  .Set("name", "test app")
+                  .Set("version", "1")
+                  .Set("app",
+                       extensions::DictionaryBuilder()
+                           .Set("background",
+                                extensions::DictionaryBuilder()
+                                    .Set("scripts", extensions::ListBuilder()
+                                                        .Append("background.js")
+                                                        .Build())
+                                    .Build())
+                           .Build())
+                  .Build())
+          .Build();
+  extensions::ExtensionRegistry* registry =
+      extensions::ExtensionRegistry::Get(profile);
+  EXPECT_TRUE(registry->AddEnabled(app));
+  return app;
+}
+
+void FetchURLRequestContext(net::URLRequestContextGetter* getter,
+                            net::URLRequestContext** context) {
+  *context = getter->GetURLRequestContext();
+}
+
+}  // namespace
+
+IN_PROC_BROWSER_TEST_F(ProfileBrowserTest, URLRequestContextIsolation) {
+  base::ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+
+  MockProfileDelegate delegate;
+  EXPECT_CALL(delegate, OnProfileCreated(testing::NotNull(), true, true));
+
+  {
+    std::unique_ptr<Profile> profile(CreateProfile(
+        temp_dir.path(), &delegate, Profile::CREATE_MODE_SYNCHRONOUS));
+
+    scoped_refptr<const extensions::Extension> app =
+        BuildTestApp(profile.get());
+    content::StoragePartition* extension_partition =
+        content::BrowserContext::GetStoragePartitionForSite(
+            profile.get(),
+            extensions::Extension::GetBaseURLFromExtensionId(app->id()));
+    net::URLRequestContextGetter* extension_context_getter =
+        extension_partition->GetURLRequestContext();
+    net::URLRequestContextGetter* main_context_getter =
+        profile->GetRequestContext();
+
+    net::URLRequestContext* extension_context = nullptr;
+    net::URLRequestContext* main_context = nullptr;
+    base::RunLoop run_loop;
+    content::BrowserThread::PostTask(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&FetchURLRequestContext, extension_context_getter,
+                   &extension_context));
+    content::BrowserThread::PostTaskAndReply(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&FetchURLRequestContext, main_context_getter, &main_context),
+        run_loop.QuitClosure());
+    run_loop.Run();
+
+    CHECK(extension_context);
+    CHECK(main_context);

[mmenke, 2016/04/27 02:28:47]

We'd crash just below if these aren't true, anyways, so I don't think we get
anything from these CHECKs.  If you prefer the test fixture not to crash, and
use ASSERTs instead, but I'm happy, either way.

[nharper, 2016/04/27 22:25:44]

Done.

+
+    EXPECT_NE(extension_context, main_context);
+    EXPECT_NE(extension_context->channel_id_service(),
+              main_context->channel_id_service());

[mmenke, 2016/04/27 02:28:47]

Dereferencing the context on the UI thread just doesn't seem like a great idea. 
Let's just get rid of FetchURLRequestContext, and make a single method that
takes two getters and compares them instead.

Also, can we compare the channel ID services set on the network sessions, too
(Can just use EXPECT_EQ to compare them with the corresponding request context's
channel ID service).

Could optionally throw in a check that the cookie stores don't match as well.

[nharper, 2016/04/27 22:25:44]

Done.

+  }
+
+  FlushIoTaskRunnerAndSpinThreads();
+}
+
+IN_PROC_BROWSER_TEST_F(ProfileBrowserTest,
+                       OffTheRecordURLRequestContextIsolation) {
+  base::ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+
+  MockProfileDelegate delegate;
+  EXPECT_CALL(delegate, OnProfileCreated(testing::NotNull(), true, true));
+
+  {
+    std::unique_ptr<Profile> profile(CreateProfile(
+        temp_dir.path(), &delegate, Profile::CREATE_MODE_SYNCHRONOUS));
+    Profile* otr_profile = profile->GetOffTheRecordProfile();
+
+    scoped_refptr<const extensions::Extension> app = BuildTestApp(otr_profile);
+    content::StoragePartition* extension_partition =
+        content::BrowserContext::GetStoragePartitionForSite(
+            otr_profile,
+            extensions::Extension::GetBaseURLFromExtensionId(app->id()));
+    net::URLRequestContextGetter* extension_context_getter =
+        extension_partition->GetURLRequestContext();
+    net::URLRequestContextGetter* main_context_getter =
+        otr_profile->GetRequestContext();
+
+    net::URLRequestContext* extension_context = nullptr;
+    net::URLRequestContext* main_context = nullptr;
+    base::RunLoop run_loop;
+    content::BrowserThread::PostTask(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&FetchURLRequestContext, extension_context_getter,
+                   &extension_context));
+    content::BrowserThread::PostTaskAndReply(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&FetchURLRequestContext, main_context_getter, &main_context),
+        run_loop.QuitClosure());
+    run_loop.Run();
+
+    CHECK(extension_context);
+    CHECK(main_context);
+
+    EXPECT_NE(extension_context, main_context);
+    EXPECT_NE(extension_context->channel_id_service(),
+              main_context->channel_id_service());
+  }
+
+  FlushIoTaskRunnerAndSpinThreads();
+}
+
 // The EndSession IO synchronization is only critical on Windows, but also
 // happens under the USE_X11 define. See BrowserProcessImpl::EndSession.
 #if defined(USE_X11) || defined(OS_WIN) || defined(USE_OZONE)
 
 namespace {
 
 std::string GetExitTypePreferenceFromDisk(Profile* profile) {
   base::FilePath prefs_path =
       profile->GetPath().Append(chrome::kPreferencesFilename);
   std::string prefs;
@@ skipping 114 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(ProfileBrowserTest,
                        URLFetcherUsingExtensionContextDuringIncognitoTeardown) {
   Browser* incognito_browser =
       OpenURLOffTheRecord(browser()->profile(), GURL("about:blank"));
 
   RunURLFetcherActiveDuringIncognitoTeardownTest(
       incognito_browser,
       incognito_browser->profile()->GetRequestContextForExtensions());
 }