1// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/services/gcm/fake_gcm_profile_service.h"
6
7#include "base/bind.h"
8#include "base/message_loop/message_loop.h"
9#include "base/strings/string_number_conversions.h"
10#include "chrome/browser/profiles/profile.h"
11#include "components/gcm_driver/fake_gcm_client_factory.h"
12#include "components/gcm_driver/fake_gcm_driver.h"
13#include "components/gcm_driver/gcm_driver.h"
14#include "content/public/browser/browser_context.h"
15
16namespace gcm {
17
18namespace {
19
20class CustomFakeGCMDriver : public FakeGCMDriver {
21 public:
22  explicit CustomFakeGCMDriver(FakeGCMProfileService* service);
23  virtual ~CustomFakeGCMDriver();
24
25  void OnRegisterFinished(const std::string& app_id,
26                          const std::string& registration_id,
27                          GCMClient::Result result);
28  void OnUnregisterFinished(const std::string& app_id,
29                            GCMClient::Result result);
30  void OnSendFinished(const std::string& app_id,
31                      const std::string& message_id,
32                      GCMClient::Result result);
33
34 protected:
35  // FakeGCMDriver overrides:
36  virtual void RegisterImpl(
37      const std::string& app_id,
38      const std::vector<std::string>& sender_ids) OVERRIDE;
39  virtual void UnregisterImpl(const std::string& app_id) OVERRIDE;
40  virtual void SendImpl(const std::string& app_id,
41                        const std::string& receiver_id,
42                        const GCMClient::OutgoingMessage& message) OVERRIDE;
43
44 private:
45  FakeGCMProfileService* service_;
46
47  DISALLOW_COPY_AND_ASSIGN(CustomFakeGCMDriver);
48};
49
50CustomFakeGCMDriver::CustomFakeGCMDriver(FakeGCMProfileService* service)
51    : service_(service) {
52}
53
54CustomFakeGCMDriver::~CustomFakeGCMDriver() {
55}
56
57void CustomFakeGCMDriver::RegisterImpl(
58    const std::string& app_id,
59    const std::vector<std::string>& sender_ids) {
60  base::MessageLoop::current()->PostTask(
61      FROM_HERE,
62      base::Bind(&FakeGCMProfileService::RegisterFinished,
63                 base::Unretained(service_),
64                 app_id,
65                 sender_ids));
66}
67
68void CustomFakeGCMDriver::UnregisterImpl(const std::string& app_id) {
69  base::MessageLoop::current()->PostTask(
70      FROM_HERE, base::Bind(
71          &FakeGCMProfileService::UnregisterFinished,
72          base::Unretained(service_),
73          app_id));
74}
75
76void CustomFakeGCMDriver::SendImpl(const std::string& app_id,
77                                   const std::string& receiver_id,
78                                   const GCMClient::OutgoingMessage& message) {
79  base::MessageLoop::current()->PostTask(
80      FROM_HERE,
81      base::Bind(&FakeGCMProfileService::SendFinished,
82                 base::Unretained(service_),
83                 app_id,
84                 receiver_id,
85                 message));
86}
87
88void CustomFakeGCMDriver::OnRegisterFinished(
89    const std::string& app_id,
90    const std::string& registration_id,
91    GCMClient::Result result) {
92  RegisterFinished(app_id, registration_id, result);
93}
94void CustomFakeGCMDriver::OnUnregisterFinished(const std::string& app_id,
95                                               GCMClient::Result result) {
96  UnregisterFinished(app_id, result);
97}
98void CustomFakeGCMDriver::OnSendFinished(const std::string& app_id,
99                                         const std::string& message_id,
100                                         GCMClient::Result result) {
101  SendFinished(app_id, message_id, result);
102}
103
104}  // namespace
105
106// static
107KeyedService* FakeGCMProfileService::Build(content::BrowserContext* context) {
108  Profile* profile = static_cast<Profile*>(context);
109  FakeGCMProfileService* service = new FakeGCMProfileService(profile);
110  service->SetDriverForTesting(new CustomFakeGCMDriver(service));
111  return service;
112}
113
114FakeGCMProfileService::FakeGCMProfileService(Profile* profile)
115    : collect_(false) {}
116
117FakeGCMProfileService::~FakeGCMProfileService() {}
118
119void FakeGCMProfileService::RegisterFinished(
120    const std::string& app_id,
121    const std::vector<std::string>& sender_ids) {
122  if (collect_) {
123    last_registered_app_id_ = app_id;
124    last_registered_sender_ids_ = sender_ids;
125  }
126
127  CustomFakeGCMDriver* custom_driver =
128      static_cast<CustomFakeGCMDriver*>(driver());
129  custom_driver->OnRegisterFinished(app_id,
130                           base::UintToString(sender_ids.size()),
131                           GCMClient::SUCCESS);
132}
133
134void FakeGCMProfileService::UnregisterFinished(const std::string& app_id) {
135  GCMClient::Result result = GCMClient::SUCCESS;
136  if (!unregister_responses_.empty()) {
137    result = unregister_responses_.front();
138    unregister_responses_.pop_front();
139  }
140
141  CustomFakeGCMDriver* custom_driver =
142      static_cast<CustomFakeGCMDriver*>(driver());
143  custom_driver->OnUnregisterFinished(app_id, result);
144}
145
146void FakeGCMProfileService::SendFinished(
147    const std::string& app_id,
148    const std::string& receiver_id,
149    const GCMClient::OutgoingMessage& message) {
150  if (collect_) {
151    last_sent_message_ = message;
152    last_receiver_id_ = receiver_id;
153  }
154
155  CustomFakeGCMDriver* custom_driver =
156      static_cast<CustomFakeGCMDriver*>(driver());
157  custom_driver->OnSendFinished(app_id, message.id, GCMClient::SUCCESS);
158}
159
160void FakeGCMProfileService::AddExpectedUnregisterResponse(
161    GCMClient::Result result) {
162  unregister_responses_.push_back(result);
163}
164
165}  // namespace gcm
166