[BackgroundSync] Use appopriate type parameters for WebCallbacks (3/4)

content/child/background_sync/background_sync_provider.cc

 // Copyright 2015 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 "content/child/background_sync/background_sync_provider.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/child/background_sync/background_sync_type_converters.h"
 #include "content/child/service_worker/web_service_worker_registration_impl.h"
@@ skipping 131 matching lines @@
     scoped_ptr<blink::WebSyncRegistrationCallbacks> callbacks,
     BackgroundSyncError error,
     const SyncRegistrationPtr& options) {
   // TODO(iclelland): Determine the correct error message to return in each case
   scoped_ptr<blink::WebSyncRegistration> result;
   switch (error) {
     case BACKGROUND_SYNC_ERROR_NONE:
       if (!options.is_null())
         result =
             mojo::ConvertTo<scoped_ptr<blink::WebSyncRegistration>>(options);
-      callbacks->onSuccess(result.release());
+      callbacks->onSuccess(blink::adoptWebPtr(result.release()));
       break;
     case BACKGROUND_SYNC_ERROR_NOT_FOUND:
       NOTREACHED();
       break;
     case BACKGROUND_SYNC_ERROR_STORAGE:
       callbacks->onError(
-          new blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
-                                  "Background Sync is disabled."));
+          blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                              "Background Sync is disabled."));
       break;
     case BACKGROUND_SYNC_ERROR_NOT_ALLOWED:
-      callbacks->onError(new blink::WebSyncError(
+      callbacks->onError(blink::WebSyncError(
           blink::WebSyncError::ErrorTypeNoPermission,
           "Cannot register a sync event without a window client."));
       break;
     case BACKGROUND_SYNC_ERROR_NO_SERVICE_WORKER:
       callbacks->onError(
-          new blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
-                                  "No service worker is active."));
+          blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                              "No service worker is active."));
       break;
   }
 }
 
 void BackgroundSyncProvider::UnregisterCallback(
     scoped_ptr<blink::WebSyncUnregistrationCallbacks> callbacks,
     BackgroundSyncError error) {
   // TODO(iclelland): Determine the correct error message to return in each case
   switch (error) {
     case BACKGROUND_SYNC_ERROR_NONE:
-      callbacks->onSuccess(new bool(true));
+      callbacks->onSuccess(true);
       break;
     case BACKGROUND_SYNC_ERROR_NOT_FOUND:
-      callbacks->onSuccess(new bool(false));
+      callbacks->onSuccess(false);
       break;
     case BACKGROUND_SYNC_ERROR_STORAGE:
       callbacks->onError(
-          new blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
-                                  "Background Sync is disabled."));
+          blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                              "Background Sync is disabled."));
       break;
     case BACKGROUND_SYNC_ERROR_NOT_ALLOWED:
       // This error should never be returned from
       // BackgroundSyncManager::Unregister
       NOTREACHED();
       break;
     case BACKGROUND_SYNC_ERROR_NO_SERVICE_WORKER:
       callbacks->onError(
-          new blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
-                                  "No service worker is active."));
+          blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                              "No service worker is active."));
       break;
   }
 }
 
 void BackgroundSyncProvider::GetRegistrationCallback(
     scoped_ptr<blink::WebSyncRegistrationCallbacks> callbacks,
     BackgroundSyncError error,
     const SyncRegistrationPtr& options) {
   // TODO(iclelland): Determine the correct error message to return in each case
   scoped_ptr<blink::WebSyncRegistration> result;
   switch (error) {
     case BACKGROUND_SYNC_ERROR_NONE:
       if (!options.is_null())
         result =
             mojo::ConvertTo<scoped_ptr<blink::WebSyncRegistration>>(options);
-      callbacks->onSuccess(result.release());
+      callbacks->onSuccess(blink::adoptWebPtr(result.release()));
       break;
     case BACKGROUND_SYNC_ERROR_NOT_FOUND:
       callbacks->onSuccess(nullptr);
       break;
     case BACKGROUND_SYNC_ERROR_STORAGE:
       callbacks->onError(
-          new blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
-                                  "Background Sync is disabled."));
+          blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                              "Background Sync is disabled."));
       break;
     case BACKGROUND_SYNC_ERROR_NOT_ALLOWED:
       // This error should never be returned from
       // BackgroundSyncManager::GetRegistration
       NOTREACHED();
       break;
     case BACKGROUND_SYNC_ERROR_NO_SERVICE_WORKER:
       callbacks->onError(
-          new blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
-                                  "No service worker is active."));
+          blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                              "No service worker is active."));
       break;
   }
 }
 
 void BackgroundSyncProvider::GetRegistrationsCallback(
     scoped_ptr<blink::WebSyncGetRegistrationsCallbacks> callbacks,
     BackgroundSyncError error,
     const mojo::Array<SyncRegistrationPtr>& registrations) {
   // TODO(iclelland): Determine the correct error message to return in each case
-  blink::WebVector<blink::WebSyncRegistration*>* results;
   switch (error) {
-    case BACKGROUND_SYNC_ERROR_NONE:
-      results = new blink::WebVector<blink::WebSyncRegistration*>(
+    case BACKGROUND_SYNC_ERROR_NONE: {
+      blink::WebVector<blink::WebSyncRegistration*> results(
           registrations.size());
       for (size_t i = 0; i < registrations.size(); ++i) {
-        (*results)[i] = mojo::ConvertTo<scoped_ptr<blink::WebSyncRegistration>>(
-                            registrations[i]).release();
+        results[i] = mojo::ConvertTo<scoped_ptr<blink::WebSyncRegistration>>(
+                         registrations[i])
+                         .release();
       }
       callbacks->onSuccess(results);
       break;
+    }
     case BACKGROUND_SYNC_ERROR_NOT_FOUND:
     case BACKGROUND_SYNC_ERROR_NOT_ALLOWED:
       // These errors should never be returned from
       // BackgroundSyncManager::GetRegistrations
       NOTREACHED();
       break;
     case BACKGROUND_SYNC_ERROR_STORAGE:
       callbacks->onError(
-          new blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
-                                  "Background Sync is disabled."));
+          blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                              "Background Sync is disabled."));
       break;
     case BACKGROUND_SYNC_ERROR_NO_SERVICE_WORKER:
       callbacks->onError(
-          new blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
-                                  "No service worker is active."));
+          blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                              "No service worker is active."));
       break;
   }
 }
 
 void BackgroundSyncProvider::GetPermissionStatusCallback(
     scoped_ptr<blink::WebSyncGetPermissionStatusCallbacks> callbacks,
     BackgroundSyncError error,
     PermissionStatus status) {
   // TODO(iclelland): Determine the correct error message to return in each case
   switch (error) {
     case BACKGROUND_SYNC_ERROR_NONE:
       switch (status) {
         case PERMISSION_STATUS_GRANTED:
-          callbacks->onSuccess(new blink::WebSyncPermissionStatus(
-              blink::WebSyncPermissionStatusGranted));
+          callbacks->onSuccess(blink::WebSyncPermissionStatusGranted);
           break;
         case PERMISSION_STATUS_DENIED:
-          callbacks->onSuccess(new blink::WebSyncPermissionStatus(
-              blink::WebSyncPermissionStatusDenied));
+          callbacks->onSuccess(blink::WebSyncPermissionStatusDenied);
           break;
         case PERMISSION_STATUS_ASK:
-          callbacks->onSuccess(new blink::WebSyncPermissionStatus(
-              blink::WebSyncPermissionStatusPrompt));
+          callbacks->onSuccess(blink::WebSyncPermissionStatusPrompt);
           break;
       }
       break;
     case BACKGROUND_SYNC_ERROR_NOT_FOUND:
     case BACKGROUND_SYNC_ERROR_NOT_ALLOWED:
       // These errors should never be returned from
       // BackgroundSyncManager::GetPermissionStatus
       NOTREACHED();
       break;
     case BACKGROUND_SYNC_ERROR_STORAGE:
       callbacks->onError(
-          new blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
-                                  "Background Sync is disabled."));
+          blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                              "Background Sync is disabled."));
       break;
     case BACKGROUND_SYNC_ERROR_NO_SERVICE_WORKER:
       callbacks->onError(
-          new blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
-                                  "No service worker is active."));
+          blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                              "No service worker is active."));
       break;
   }
 }
 
 BackgroundSyncServicePtr&
 BackgroundSyncProvider::GetBackgroundSyncServicePtr() {
   if (!background_sync_service_.get()) {
     service_registry_->ConnectToRemoteService(
         mojo::GetProxy(&background_sync_service_));
   }
   return background_sync_service_;
 }
 
 }  // namespace content