Plumb invalidations from Tango to the extensions code for the Push Messaging API.

chrome/browser/extensions/api/push_messaging/push_messaging_invalidation_handler.cc

+// Copyright (c) 2012 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/extensions/api/push_messaging/push_messaging_invalidation_handler.h"
+
+#include <algorithm>
+
+#include "base/string_number_conversions.h"
+#include "base/stringprintf.h"
+#include "chrome/browser/extensions/api/push_messaging/push_messaging_invalidation_handler_observer.h"
+#include "chrome/browser/sync/invalidation_service.h"
+#include "google/cacheinvalidation/types.pb.h"
+
+namespace extensions {
+
+namespace {
+
+const int kNumberOfSubchannels = 4;
+
+const int kFormatTypeIndex = 0;
+const int kFormatTypeLength = 1;
+const int kProjectIdIndex = 1;
+const int kProjectIdLength = 2;
+const int kExtensionIdIndex = 3;
+const int kExtensionIdLength = 32;
+const int kSubchannelIndex = 35;
+const int kSubchannelLength = 1;
+
+// Chrome Components object IDs currently have the following format:
+// <1 byte format type>
+//   Currently the only format type defined is 'U' but we'll need to create a
+//   new one.
+// <8 byte GAIA ID>
+//   Handled entirely server-side. The client never see this.
+// <2 byte project ID>
+//   We use "PM" for Push Messaging.
+// <4-48 byte project object ID>
+//   We use the extension ID concatenated with the subchannel.
+syncer::ObjectIdSet ExtensionIdToObjectIds(const std::string& extension_id) {
+  syncer::ObjectIdSet object_ids;
+  for (int i = 0; i < kNumberOfSubchannels; ++i) {
+    std::string name = base::StringPrintf("UPM%s%d", extension_id.c_str(), i);
+    object_ids.insert(invalidation::ObjectId(
+        ipc::invalidation::ObjectSource::CHROME_COMPONENTS,
+        name));
+  }
+  return object_ids;
+}
+
+// Returns true iff the conversion was successful.
+bool ObjectIdToExtensionAndSubchannel(const invalidation::ObjectId& object_id,
+                                      std::string* extension_id,
+                                      int* subchannel) {
+  if (object_id.source() !=
+      ipc::invalidation::ObjectSource::CHROME_COMPONENTS) {
+    DLOG(WARNING) << "Invalid source: " << object_id.source();
+    return false;
+  }
+
+  const std::string& name = object_id.name();
+  const size_t kValidObjectIdLength = kFormatTypeLength + kProjectIdLength +
+      kExtensionIdLength + kSubchannelLength;
+  if (name.size() != kValidObjectIdLength) {
+    DLOG(WARNING) << "Invalid length for object name " << name;
+    return false;
+  }
+  if (name.compare(kFormatTypeIndex, kFormatTypeLength, "U")) {
+    DLOG(WARNING) << "Invalid format type for object name " << name;
+    return false;
+  }
+  if (name.compare(kProjectIdIndex, kProjectIdLength, "PM")) {
+    DLOG(WARNING) << "Invalid project ID for object name " << name;
+    return false;
+  }
+  *extension_id = name.substr(kExtensionIdIndex, kExtensionIdLength);
+  if (!base::StringToInt(name.substr(kSubchannelIndex, kSubchannelLength),
+                         subchannel)) {
+    DLOG(WARNING) << "Subchannel not a number for object name " << name;
+    return false;
+  }
+
+  // We don't need to check for negative since the length check makes it
+  // impossible.
+  return *subchannel <= 3;
+}
+
+}  // namespace
+
+PushMessagingInvalidationHandler::PushMessagingInvalidationHandler(
+    InvalidationService* service,
+    PushMessagingInvalidationHandlerObserver* observer,
+    const std::set<std::string>& extension_ids)
+    : service_(service),
+      registered_extensions_(extension_ids),
+      observer_(observer) {
+  DCHECK(service_);
+  service_->RegisterInvalidationHandler(this);
+  UpdateRegistrations();
+}
+
+PushMessagingInvalidationHandler::~PushMessagingInvalidationHandler() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  service_->UnregisterInvalidationHandler(this);
+}
+
+void PushMessagingInvalidationHandler::RegisterExtension(
+    const std::string& extension_id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(32U, extension_id.size());
+  registered_extensions_.insert(extension_id);
+  UpdateRegistrations();
+}
+
+void PushMessagingInvalidationHandler::UnregisterExtension(
+    const std::string& extension_id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(32U, extension_id.size());
+  registered_extensions_.erase(extension_id);
+  UpdateRegistrations();
+}
+
+void PushMessagingInvalidationHandler::OnNotificationsEnabled() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  // Nothing to do.
+}
+
+void PushMessagingInvalidationHandler::OnNotificationsDisabled(
+    syncer::NotificationsDisabledReason reason) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  // Nothing to do.
+}
+
+void PushMessagingInvalidationHandler::OnIncomingNotification(
+    const syncer::ObjectIdPayloadMap& id_payloads,
+    syncer::IncomingNotificationSource source) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  for (syncer::ObjectIdPayloadMap::const_iterator it = id_payloads.begin();
+       it != id_payloads.end(); ++it) {
+    std::string extension_id;
+    int subchannel;
+    if (ObjectIdToExtensionAndSubchannel(it->first,
+                                         &extension_id,
+                                         &subchannel)) {
+      observer_->OnMessage(extension_id, subchannel, it->second);
+    }
+  }
+}
+
+void PushMessagingInvalidationHandler::UpdateRegistrations() {
+  syncer::ObjectIdSet ids;
+  for (std::set<std::string>::const_iterator it =
+       registered_extensions_.begin(); it != registered_extensions_.end();
+       ++it) {
+    const syncer::ObjectIdSet& object_ids = ExtensionIdToObjectIds(*it);
+    ids.insert(object_ids.begin(), object_ids.end());
+  }
+  service_->UpdateRegisteredInvalidationIds(this, ids);
+}
+
+}  // namespace extensions