Tests for the Copresence API.

chrome/browser/extensions/api/copresence/copresence_api.cc

 // Copyright 2014 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/copresence/copresence_api.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/linked_ptr.h"
 #include "chrome/browser/copresence/chrome_whispernet_client.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/api/copresence.h"
 #include "components/copresence/proto/data.pb.h"
 #include "components/copresence/proto/enums.pb.h"
 #include "components/copresence/proto/rpcs.pb.h"
-#include "components/copresence/public/copresence_client.h"
+#include "components/copresence/public/copresence_manager.h"
 #include "components/copresence/public/whispernet_client.h"
 #include "content/public/browser/browser_context.h"
 #include "extensions/browser/event_router.h"
 
 namespace extensions {
 
 namespace {
 
 base::LazyInstance<BrowserContextKeyedAPIFactory<CopresenceService> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 const char kInvalidOperationsMessage[] =
     "Invalid operation in operations array.";
 const char kShuttingDownMessage[] = "Shutting down.";
 
 }  // namespace
 
 // CopresenceService implementation:
 
 CopresenceService::CopresenceService(content::BrowserContext* context)
     : is_shutting_down_(false), browser_context_(context) {}
 
 CopresenceService::~CopresenceService() {}
 
-copresence::CopresenceClient* CopresenceService::client() {
-  if (!client_ && !is_shutting_down_)
-    client_.reset(new copresence::CopresenceClient(this));
-  return client_.get();
+copresence::CopresenceManager* CopresenceService::manager() {
+  if (!manager_ && !is_shutting_down_)
+    manager_ = copresence::CopresenceManager::Create(this);
+  return manager_.get();
 }
 
 copresence::WhispernetClient* CopresenceService::whispernet_client() {
   if (!whispernet_client_ && !is_shutting_down_)
     whispernet_client_.reset(new ChromeWhispernetClient(browser_context_));
   return whispernet_client_.get();
 }
 
 void CopresenceService::Shutdown() {
   is_shutting_down_ = true;
-  client_.reset();
+  manager_.reset();
   whispernet_client_.reset();
 }
 
+void CopresenceService::set_manager_for_testing(
+    scoped_ptr<copresence::CopresenceManager> manager) {
+  manager_ = manager.Pass();
+}
+
 // static
 BrowserContextKeyedAPIFactory<CopresenceService>*
 CopresenceService::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 void CopresenceService::HandleMessages(
     const std::string& /* app_id */,
     const std::string& subscription_id,
     const std::vector<copresence::Message>& messages) {
@@ skipping 43 matching lines @@
   return api_key_;
 }
 
 copresence::WhispernetClient* CopresenceService::GetWhispernetClient() {
   return whispernet_client();
 }
 
 template <>
 void
 BrowserContextKeyedAPIFactory<CopresenceService>::DeclareFactoryDependencies() {
+  DCHECK(ExtensionsBrowserClient::Get());
   DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
 }
 
 // CopresenceExecuteFunction implementation:
 ExtensionFunction::ResponseAction CopresenceExecuteFunction::Run() {
   scoped_ptr<api::copresence::Execute::Params> params(
       api::copresence::Execute::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   CopresenceService* service =
       CopresenceService::GetFactoryInstance()->Get(browser_context());
 
   // This can only happen if we're shutting down. In all other cases, if we
   // don't have a client, we'll create one.
-  if (!service->client())
+  if (!service->manager())
     return RespondNow(Error(kShuttingDownMessage));
 
   // Each execute will correspond to one ReportRequest protocol buffer.
   copresence::ReportRequest request;
   if (!PrepareReportRequestProto(params->operations,
                                  extension_id(),
                                  &service->apps_by_subscription_id(),
                                  &request)) {
     return RespondNow(Error(kInvalidOperationsMessage));
   }
 
-  service->client()->ExecuteReportRequest(
+  service->manager()->ExecuteReportRequest(
       request,
       extension_id(),
       base::Bind(&CopresenceExecuteFunction::SendResult, this));
   return RespondLater();
 }
 
 void CopresenceExecuteFunction::SendResult(
     copresence::CopresenceStatus status) {
   api::copresence::ExecuteStatus api_status =
       (status == copresence::SUCCESS) ? api::copresence::EXECUTE_STATUS_SUCCESS
                                       : api::copresence::EXECUTE_STATUS_FAILED;
   Respond(ArgumentList(api::copresence::Execute::Results::Create(api_status)));
 }
 
 // CopresenceSetApiKeyFunction implementation:
 ExtensionFunction::ResponseAction CopresenceSetApiKeyFunction::Run() {
   scoped_ptr<api::copresence::SetApiKey::Params> params(
       api::copresence::SetApiKey::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // The api key may be set to empty, to clear it.
   CopresenceService::GetFactoryInstance()->Get(browser_context())
       ->set_api_key(params->api_key);
   return RespondNow(NoArguments());
 }
 
 }  // namespace extensions