Commit InvalidationService implementations

chrome/browser/invalidation/p2p_invalidation_service.cc

Index: chrome/browser/invalidation/p2p_invalidation_service.cc
diff --git a/chrome/browser/invalidation/p2p_invalidation_service.cc b/chrome/browser/invalidation/p2p_invalidation_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..bef270092386f00dd8c99a36834b6191d01b8468
--- /dev/null
+++ b/chrome/browser/invalidation/p2p_invalidation_service.cc
@@ -0,0 +1,82 @@
+// Copyright (c) 2013 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/invalidation/p2p_invalidation_service.h"
+
+#include "base/command_line.h"
+#include "chrome/browser/invalidation/invalidation_service_util.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_switches.h"
+#include "jingle/notifier/base/notifier_options.h"
+#include "jingle/notifier/listener/push_client.h"
+#include "sync/notifier/p2p_invalidator.h"
+
+namespace net {
+class URLRequestContextGetter;
+}
+
+namespace invalidation {
+
+P2PInvalidationService::P2PInvalidationService() {
+}
+
+P2PInvalidationService::~P2PInvalidationService() {
+}
+
+void P2PInvalidationService::Init(Profile* profile) {
+  notifier::NotifierOptions notifier_options =
+      ParseNotifierOptions(*CommandLine::ForCurrentProcess());
+  notifier_options.request_context_getter = profile->GetRequestContext();
+  invalidator_id_ = GenerateInvalidatorClientId();

[tim (not reviewing), 2013/05/03 17:48:23]

Wouldn't hurt to DCHECK or CHECK the id is non empty. Maybe in
GenerateInvalidatorClientId, so that it's clear that function should never
return an empty Id regardless of how it's implemented down the road.

[rlarocque, 2013/05/03 22:16:14]

The comment for GenerateInvalidatorClientId() is currently "// Generates a
unique client ID for the invalidator."

I think that implies that it will always return a non-empty string.

[tim (not reviewing), 2013/05/03 22:23:50]

It seems sloppy to ignore the return value of Encode and not make an assertion
anywhere that we're ignoring it because we're passing something in that we
expect to never fail encoding.

[rlarocque, 2013/05/03 22:49:34]

I added the DCHECK.  I still don't understand how it could possibly fail,
though.  This is the same code we've been using for years to generate sync's
unique client ID.

+  invalidator_.reset(new syncer::P2PInvalidator(
+          notifier::PushClient::CreateDefault(notifier_options),
+          invalidator_id_,
+          syncer::NOTIFY_ALL));
+}
+
+void P2PInvalidationService::UpdateCredentials(const std::string& username,
+                                               const std::string& password) {
+  invalidator_->UpdateCredentials(username, password);
+}
+
+void P2PInvalidationService::Shutdown() {
+  invalidator_.reset();
+}
+
+void P2PInvalidationService::RegisterInvalidationHandler(
+    syncer::InvalidationHandler* handler) {
+  invalidator_->RegisterHandler(handler);
+}
+
+void P2PInvalidationService::UpdateRegisteredInvalidationIds(
+    syncer::InvalidationHandler* handler,
+    const syncer::ObjectIdSet& ids) {
+  invalidator_->UpdateRegisteredIds(handler, ids);
+}
+
+void P2PInvalidationService::UnregisterInvalidationHandler(
+    syncer::InvalidationHandler* handler) {
+  invalidator_->UnregisterHandler(handler);
+}
+
+void P2PInvalidationService::AcknowledgeInvalidation(
+    const invalidation::ObjectId& id,
+    const syncer::AckHandle& ack_handle) {
+  invalidator_->Acknowledge(id, ack_handle);
+}
+
+void P2PInvalidationService::SendInvalidation(
+    const syncer::ObjectIdInvalidationMap& invalidation_map) {
+  invalidator_->SendInvalidation(invalidation_map);
+}
+
+syncer::InvalidatorState P2PInvalidationService::GetInvalidatorState() const {
+  return invalidator_->GetInvalidatorState();
+}
+
+std::string P2PInvalidationService::GetInvalidatorClientId() const {
+  return invalidator_id_;
+}
+
+}  // namespace invalidation