[BackgroundSync] Add new registration options from the spec

content/browser/background_sync/background_sync_manager.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/browser/background_sync/background_sync_manager.h"
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
-#include "content/browser/background_sync/background_sync.pb.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_storage.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace {
 const char kBackgroundSyncUserDataKey[] = "BackgroundSyncUserData";
 }
 
 namespace content {
 
@@ skipping 167 matching lines @@
       for (int i = 0, max = registrations_proto.registration_size(); i < max;
            ++i) {
         const BackgroundSyncRegistrationProto& registration_proto =
             registrations_proto.registration(i);
 
         if (registration_proto.id() >= registrations->next_id) {
           corruption_detected = true;
           break;
         }
 
-        BackgroundSyncRegistration registration(registration_proto.id(),
-                                                registration_proto.name());
-        if (registration_proto.has_min_period())
-          registration.min_period = registration_proto.min_period();
-        registrations->name_to_registration_map[registration_proto.name()] =
-            registration;
+        BackgroundSyncRegistration* registration =
+            &registrations->name_to_registration_map[registration_proto.name()];
+
+        registration->id = registration_proto.id();
+        registration->name = registration_proto.name();
+        registration->fire_once = registration_proto.fire_once();
+        registration->min_period = registration_proto.min_period();
+        registration->network_state = registration_proto.network_state();
+        registration->power_state = registration_proto.power_state();
       }
     }
 
     if (corruption_detected)
       break;
   }
 
   if (corruption_detected) {
     LOG(ERROR) << "Corruption detected in background sync backend";
     DisableAndClearManager(base::Bind(callback));
@@ skipping 122 matching lines @@
   registrations_proto.set_next_registration_id(registrations.next_id);
 
   for (const auto& name_and_registration :
        registrations.name_to_registration_map) {
     const BackgroundSyncRegistration& registration =
         name_and_registration.second;
     BackgroundSyncRegistrationProto* registration_proto =
         registrations_proto.add_registration();
     registration_proto->set_id(registration.id);
     registration_proto->set_name(registration.name);
-    if (registration.min_period != 0)
-      registration_proto->set_min_period(registration.min_period);
+    registration_proto->set_fire_once(registration.fire_once);
+    registration_proto->set_min_period(registration.min_period);
+    registration_proto->set_network_state(registration.network_state);
+    registration_proto->set_power_state(registration.power_state);
   }
   std::string serialized;
   bool success = registrations_proto.SerializeToString(&serialized);
   DCHECK(success);
 
   StoreDataInBackend(sw_registration_id, origin, kBackgroundSyncUserDataKey,
                      serialized, callback);
 }
 
 void BackgroundSyncManager::RegisterDidStore(
@@ skipping 212 matching lines @@
       weak_ptr_factory_.GetWeakPtr(), callback);
 }
 
 BackgroundSyncManager::StatusCallback
 BackgroundSyncManager::MakeStatusCompletion(const StatusCallback& callback) {
   return base::Bind(&BackgroundSyncManager::PendingStatusCallback,
                     weak_ptr_factory_.GetWeakPtr(), callback);
 }
 
 }  // namespace content