OLD | NEW |
(Empty) | |
| 1 // Copyright 2014 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 "content/browser/geofencing/geofencing_service.h" |
| 6 |
| 7 #include "base/memory/singleton.h" |
| 8 #include "base/message_loop/message_loop.h" |
| 9 #include "content/browser/geofencing/geofencing_provider.h" |
| 10 #include "content/browser/geofencing/geofencing_registration_delegate.h" |
| 11 #include "content/public/browser/browser_thread.h" |
| 12 #include "third_party/WebKit/public/platform/WebCircularGeofencingRegion.h" |
| 13 |
| 14 namespace content { |
| 15 |
| 16 namespace { |
| 17 |
| 18 void RunSoon(const base::Closure& callback) { |
| 19 if (!callback.is_null()) |
| 20 base::MessageLoop::current()->PostTask(FROM_HERE, callback); |
| 21 } |
| 22 |
| 23 } // namespace |
| 24 |
| 25 struct GeofencingServiceImpl::Registration { |
| 26 Registration(); |
| 27 Registration(const blink::WebCircularGeofencingRegion& region, |
| 28 int64 geofencing_registration_id, |
| 29 GeofencingRegistrationDelegate* delegate); |
| 30 |
| 31 blink::WebCircularGeofencingRegion region; |
| 32 int64 geofencing_registration_id; |
| 33 GeofencingRegistrationDelegate* delegate; |
| 34 |
| 35 enum RegistrationState { |
| 36 // In progress of being registered with provider. |
| 37 STATE_REGISTERING, |
| 38 // Currently registered with provider. |
| 39 STATE_REGISTERED, |
| 40 // In progress of being registered with provider, but should be unregistered |
| 41 // and deleted. |
| 42 STATE_SHOULD_UNREGISTER_AND_DELETE, |
| 43 // Not currently registered with provider, but still an active registration. |
| 44 STATE_UNREGISTERED |
| 45 }; |
| 46 RegistrationState state; |
| 47 }; |
| 48 |
| 49 GeofencingServiceImpl::Registration::Registration() |
| 50 : geofencing_registration_id(-1), |
| 51 delegate(nullptr), |
| 52 state(STATE_UNREGISTERED) { |
| 53 } |
| 54 |
| 55 GeofencingServiceImpl::Registration::Registration( |
| 56 const blink::WebCircularGeofencingRegion& region, |
| 57 int64 geofencing_registration_id, |
| 58 GeofencingRegistrationDelegate* delegate) |
| 59 : region(region), |
| 60 geofencing_registration_id(geofencing_registration_id), |
| 61 delegate(delegate), |
| 62 state(STATE_REGISTERING) { |
| 63 } |
| 64 |
| 65 GeofencingServiceImpl::GeofencingServiceImpl() : next_registration_id_(0) { |
| 66 } |
| 67 |
| 68 GeofencingServiceImpl::~GeofencingServiceImpl() { |
| 69 } |
| 70 |
| 71 GeofencingServiceImpl* GeofencingServiceImpl::GetInstance() { |
| 72 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 73 return Singleton<GeofencingServiceImpl>::get(); |
| 74 } |
| 75 |
| 76 bool GeofencingServiceImpl::IsServiceAvailable() { |
| 77 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 78 return EnsureProvider(); |
| 79 } |
| 80 |
| 81 int64 GeofencingServiceImpl::RegisterRegion( |
| 82 const blink::WebCircularGeofencingRegion& region, |
| 83 GeofencingRegistrationDelegate* delegate) { |
| 84 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 85 |
| 86 int64 geofencing_registration_id = GetNextId(); |
| 87 registrations_[geofencing_registration_id] = |
| 88 Registration(region, geofencing_registration_id, delegate); |
| 89 |
| 90 if (!EnsureProvider()) { |
| 91 RunSoon( |
| 92 base::Bind(&GeofencingServiceImpl::NotifyRegistrationFinished, |
| 93 base::Unretained(this), |
| 94 geofencing_registration_id, |
| 95 GEOFENCING_STATUS_OPERATION_FAILED_SERVICE_NOT_AVAILABLE)); |
| 96 return geofencing_registration_id; |
| 97 } |
| 98 |
| 99 provider_->RegisterRegion( |
| 100 geofencing_registration_id, |
| 101 region, |
| 102 base::Bind(&GeofencingServiceImpl::NotifyRegistrationFinished, |
| 103 base::Unretained(this), |
| 104 geofencing_registration_id)); |
| 105 return geofencing_registration_id; |
| 106 } |
| 107 |
| 108 void GeofencingServiceImpl::UnregisterRegion(int64 geofencing_registration_id) { |
| 109 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 110 |
| 111 RegistrationsMap::iterator registration_iterator = |
| 112 registrations_.find(geofencing_registration_id); |
| 113 DCHECK(registration_iterator != registrations_.end()); |
| 114 |
| 115 if (!EnsureProvider()) |
| 116 return; |
| 117 |
| 118 switch (registration_iterator->second.state) { |
| 119 case Registration::STATE_REGISTERED: |
| 120 provider_->UnregisterRegion(geofencing_registration_id); |
| 121 // fallthru |
| 122 case Registration::STATE_UNREGISTERED: |
| 123 registrations_.erase(registration_iterator); |
| 124 break; |
| 125 case Registration::STATE_REGISTERING: |
| 126 // Update state, NotifyRegistrationFinished will take care of actually |
| 127 // unregistering. |
| 128 registration_iterator->second.state = |
| 129 Registration::STATE_SHOULD_UNREGISTER_AND_DELETE; |
| 130 break; |
| 131 case Registration::STATE_SHOULD_UNREGISTER_AND_DELETE: |
| 132 // Should not happen. |
| 133 NOTREACHED(); |
| 134 break; |
| 135 } |
| 136 } |
| 137 |
| 138 void GeofencingServiceImpl::SetProviderForTesting( |
| 139 scoped_ptr<GeofencingProvider> provider) { |
| 140 DCHECK(!provider_.get()); |
| 141 provider_ = provider.Pass(); |
| 142 } |
| 143 |
| 144 int GeofencingServiceImpl::RegistrationCountForTesting() { |
| 145 return registrations_.size(); |
| 146 } |
| 147 |
| 148 bool GeofencingServiceImpl::EnsureProvider() { |
| 149 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 150 |
| 151 if (!provider_) { |
| 152 // TODO(mek): Create platform specific provider. |
| 153 return false; |
| 154 } |
| 155 return true; |
| 156 } |
| 157 |
| 158 int64 GeofencingServiceImpl::GetNextId() { |
| 159 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 160 |
| 161 return next_registration_id_++; |
| 162 } |
| 163 |
| 164 void GeofencingServiceImpl::NotifyRegistrationFinished( |
| 165 int64 geofencing_registration_id, |
| 166 GeofencingStatus status) { |
| 167 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 168 |
| 169 RegistrationsMap::iterator registration_iterator = |
| 170 registrations_.find(geofencing_registration_id); |
| 171 DCHECK(registration_iterator != registrations_.end()); |
| 172 DCHECK(registration_iterator->second.state == |
| 173 Registration::STATE_REGISTERING || |
| 174 registration_iterator->second.state == |
| 175 Registration::STATE_SHOULD_UNREGISTER_AND_DELETE); |
| 176 |
| 177 if (registration_iterator->second.state == |
| 178 Registration::STATE_SHOULD_UNREGISTER_AND_DELETE) { |
| 179 // Don't call delegate, but unregister with provider if registration was |
| 180 // succesfull. |
| 181 if (status == GEOFENCING_STATUS_OK) { |
| 182 provider_->UnregisterRegion(geofencing_registration_id); |
| 183 } |
| 184 registrations_.erase(registration_iterator); |
| 185 return; |
| 186 } |
| 187 |
| 188 // Normal case, mark as registered and call delegate. |
| 189 registration_iterator->second.state = Registration::STATE_REGISTERED; |
| 190 registration_iterator->second.delegate->RegistrationFinished( |
| 191 geofencing_registration_id, status); |
| 192 |
| 193 if (status != GEOFENCING_STATUS_OK) { |
| 194 // Registration failed, remove from our book-keeping. |
| 195 registrations_.erase(registration_iterator); |
| 196 } |
| 197 } |
| 198 |
| 199 } // namespace content |
OLD | NEW |