Get rid of the ProfileId. It was added for ceee. I reverted the original change, since it led to ...

chrome/browser/extensions/extension_webrequest_api_unittest.cc

 // Copyright (c) 2011 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 <queue>
 
 #include "base/file_util.h"
 #include "base/path_service.h"
 
 #include "chrome/browser/extensions/extension_event_router_forwarder.h"
 #include "chrome/browser/extensions/extension_webrequest_api.h"
 #include "chrome/browser/extensions/extension_webrequest_api_constants.h"
 #include "chrome/browser/net/chrome_network_delegate.h"
 #include "chrome/browser/prefs/pref_member.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/testing_pref_service.h"
 #include "chrome/test/testing_profile.h"
 #include "net/base/net_util.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace keys = extension_webrequest_api_constants;
 
 namespace {
 static void EventHandledOnIOThread(
-    ProfileId profile_id,
+    void* profile,
     const std::string& extension_id,
     const std::string& event_name,
     const std::string& sub_event_name,
     uint64 request_id,
     ExtensionWebRequestEventRouter::EventResponse* response) {
   ExtensionWebRequestEventRouter::GetInstance()->OnEventHandled(
-      profile_id, extension_id, event_name, sub_event_name, request_id,
+      profile, extension_id, event_name, sub_event_name, request_id,
       response);
 }
 }  // namespace
 
 // A mock event router that responds to events with a pre-arranged queue of
 // Tasks.
 class TestIPCSender : public IPC::Message::Sender {
 public:
   // Adds a Task to the queue. We will fire these in order as events are
   // dispatched.
@@ skipping 19 matching lines @@
   std::queue<Task*> task_queue_;
 };
 
 class ExtensionWebRequestTest : public testing::Test {
 protected:
   virtual void SetUp() {
     event_router_ = new ExtensionEventRouterForwarder();
     enable_referrers_.Init(
         prefs::kEnableReferrers, profile_.GetTestingPrefService(), NULL);
     network_delegate_.reset(new ChromeNetworkDelegate(
-        event_router_.get(), NULL, profile_.GetRuntimeId(),
-        &enable_referrers_));
+        event_router_.get(), NULL, &profile_, &enable_referrers_));
     context_ = new TestURLRequestContext();
     context_->set_network_delegate(network_delegate_.get());
   }
 
   MessageLoopForIO io_loop_;
   TestingProfile profile_;
   TestDelegate delegate_;
   BooleanPrefMember enable_referrers_;
   TestIPCSender ipc_sender_;
   scoped_refptr<ExtensionEventRouterForwarder> event_router_;
   scoped_refptr<ExtensionInfoMap> extension_info_map_;
   scoped_ptr<ChromeNetworkDelegate> network_delegate_;
   scoped_refptr<TestURLRequestContext> context_;
 };
 
 // Tests that we handle disagreements among extensions about responses to
 // blocking events by choosing the response from the most-recently-installed
 // extension.
 TEST_F(ExtensionWebRequestTest, BlockingEventPrecedence) {
   std::string extension1_id("1");
   std::string extension2_id("2");
   ExtensionWebRequestEventRouter::RequestFilter filter;
   const std::string kEventName(keys::kOnBeforeRequest);
   base::WeakPtrFactory<TestIPCSender> ipc_sender_factory(&ipc_sender_);
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
-      profile_.GetRuntimeId(), extension1_id, kEventName,
-      kEventName + "/1", filter,
+      &profile_, extension1_id, kEventName, kEventName + "/1", filter,
       ExtensionWebRequestEventRouter::ExtraInfoSpec::BLOCKING,
       ipc_sender_factory.GetWeakPtr());
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
-      profile_.GetRuntimeId(), extension2_id, kEventName,
-      kEventName + "/2", filter,
+      &profile_, extension2_id, kEventName, kEventName + "/2", filter,
       ExtensionWebRequestEventRouter::ExtraInfoSpec::BLOCKING,
       ipc_sender_factory.GetWeakPtr());
 
   net::URLRequest request(GURL("about:blank"), &delegate_);
   request.set_context(context_);
 
   {
     // onBeforeRequest will be dispatched twice initially. The second response -
     // the redirect - should win, since it has a later |install_time|. The
     // redirect will dispatch another pair of onBeforeRequest. There, the first
     // response should win (later |install_time|).
     GURL redirect_url("about:redirected");
     ExtensionWebRequestEventRouter::EventResponse* response = NULL;
 
     // Extension1 response. Arrives first, but ignored due to install_time.
     response = new ExtensionWebRequestEventRouter::EventResponse(
         extension1_id, base::Time::FromDoubleT(1));
     response->cancel = true;
     ipc_sender_.PushTask(
         NewRunnableFunction(&EventHandledOnIOThread,
-            profile_.GetRuntimeId(), extension1_id,
-            kEventName, kEventName + "/1", request.identifier(), response));
+            &profile_, extension1_id, kEventName, kEventName + "/1",
+            request.identifier(), response));
 
     // Extension2 response. Arrives second, and chosen because of install_time.
     response = new ExtensionWebRequestEventRouter::EventResponse(
         extension2_id, base::Time::FromDoubleT(2));
     response->new_url = redirect_url;
     ipc_sender_.PushTask(
         NewRunnableFunction(&EventHandledOnIOThread,
-            profile_.GetRuntimeId(), extension2_id,
-            kEventName, kEventName + "/2", request.identifier(), response));
+            &profile_, extension2_id, kEventName, kEventName + "/2",
+            request.identifier(), response));
 
     // Extension2 response to the redirected URL. Arrives first, and chosen.
     response = new ExtensionWebRequestEventRouter::EventResponse(
         extension2_id, base::Time::FromDoubleT(2));
     ipc_sender_.PushTask(
         NewRunnableFunction(&EventHandledOnIOThread,
-            profile_.GetRuntimeId(), extension2_id,
-            kEventName, kEventName + "/2", request.identifier(), response));
+            &profile_, extension2_id, kEventName, kEventName + "/2",
+            request.identifier(), response));
 
     // Extension1 response to the redirected URL. Arrives second, and ignored.
     response = new ExtensionWebRequestEventRouter::EventResponse(
         extension1_id, base::Time::FromDoubleT(1));
     response->cancel = true;
     ipc_sender_.PushTask(
         NewRunnableFunction(&EventHandledOnIOThread,
-            profile_.GetRuntimeId(), extension1_id,
-            kEventName, kEventName + "/1", request.identifier(), response));
+            &profile_, extension1_id, kEventName, kEventName + "/1",
+            request.identifier(), response));
 
     request.Start();
     MessageLoop::current()->Run();
 
     EXPECT_TRUE(!request.is_pending());
     EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status());
     EXPECT_EQ(0, request.status().os_error());
     EXPECT_EQ(redirect_url, request.url());
     EXPECT_EQ(2U, request.url_chain().size());
     EXPECT_EQ(0U, ipc_sender_.GetNumTasks());
   }
 }