Move ProfileKeyedAPI implementations to take BrowserContext in the constructor (part 1).

chrome/browser/extensions/api/cast_channel/cast_channel_api.cc

 // Copyright 2013 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/extensions/api/cast_channel/cast_channel_api.h"
 
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/cast_channel/cast_socket.h"
 #include "chrome/browser/net/chrome_net_log.h"
-#include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_system.h"
 #include "net/base/net_errors.h"
 #include "url/gurl.h"
 
 namespace extensions {
 
 namespace Close = cast_channel::Close;
 namespace OnError = cast_channel::OnError;
@@ skipping 13 matching lines @@
 template <class T>
 std::string ParamToString(const T& info) {
   scoped_ptr<base::DictionaryValue> dict = info.ToValue();
   std::string out;
   base::JSONWriter::Write(dict.get(), &out);
   return out;
 }
 
 }  // namespace
 
-CastChannelAPI::CastChannelAPI(Profile* profile)
-  : profile_(profile) {
-  DCHECK(profile_);
+CastChannelAPI::CastChannelAPI(content::BrowserContext* context)
+    : browser_context_(context) {
+  DCHECK(browser_context_);
 }
 
 // static
-CastChannelAPI* CastChannelAPI::Get(Profile* profile) {
-  return ProfileKeyedAPIFactory<CastChannelAPI>::GetForProfile(profile);
+CastChannelAPI* CastChannelAPI::Get(content::BrowserContext* context) {
+  return ProfileKeyedAPIFactory<CastChannelAPI>::GetForProfile(context);
 }
 
 static base::LazyInstance<ProfileKeyedAPIFactory<CastChannelAPI> > g_factory =
     LAZY_INSTANCE_INITIALIZER;
 
 // static
 ProfileKeyedAPIFactory<CastChannelAPI>* CastChannelAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
@@ skipping 13 matching lines @@
 }
 
 void CastChannelAPI::OnError(const CastSocket* socket,
                              cast_channel::ChannelError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   ChannelInfo channel_info;
   socket->FillChannelInfo(&channel_info);
   channel_info.error_state = error;
   scoped_ptr<base::ListValue> results = OnError::Create(channel_info);
   scoped_ptr<Event> event(new Event(OnError::kEventName, results.Pass()));
-  extensions::ExtensionSystem::Get(profile_)->event_router()->
-    DispatchEventToExtension(socket->owner_extension_id(), event.Pass());
+  extensions::ExtensionSystem::Get(browser_context_)
+      ->event_router()
+      ->DispatchEventToExtension(socket->owner_extension_id(), event.Pass());
 }
 
 void CastChannelAPI::OnMessage(const CastSocket* socket,
                                const MessageInfo& message_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   ChannelInfo channel_info;
   socket->FillChannelInfo(&channel_info);
   scoped_ptr<base::ListValue> results =
     OnMessage::Create(channel_info, message_info);
   VLOG(1) << "Sending message " << ParamToString(message_info)
           << " to channel " << ParamToString(channel_info);
   scoped_ptr<Event> event(new Event(OnMessage::kEventName, results.Pass()));
-  extensions::ExtensionSystem::Get(profile_)->event_router()->
-    DispatchEventToExtension(socket->owner_extension_id(), event.Pass());
+  extensions::ExtensionSystem::Get(browser_context_)
+      ->event_router()
+      ->DispatchEventToExtension(socket->owner_extension_id(), event.Pass());
 }
 
 CastChannelAPI::~CastChannelAPI() {}
 
 CastChannelAsyncApiFunction::CastChannelAsyncApiFunction()
   : manager_(NULL), error_(cast_channel::CHANNEL_ERROR_NONE) { }
 
 CastChannelAsyncApiFunction::~CastChannelAsyncApiFunction() { }
 
 bool CastChannelAsyncApiFunction::PrePrepare() {
@@ skipping 144 matching lines @@
     SetResultFromError(cast_channel::CHANNEL_ERROR_SOCKET_ERROR);
   } else {
     int channel_id = params_->channel.channel_id;
     SetResultFromSocket(channel_id);
     RemoveSocket(channel_id);
   }
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions