[Sync] Create UserEventService.

components/sync/user_events/user_event_service.h

Index: components/sync/user_events/user_event_service.h
diff --git a/components/sync/user_events/user_event_service.h b/components/sync/user_events/user_event_service.h
new file mode 100644
index 0000000000000000000000000000000000000000..f460d6c358bf5e30f71e5459aadd8a1e6e07f8db
--- /dev/null
+++ b/components/sync/user_events/user_event_service.h
@@ -0,0 +1,59 @@
+// Copyright 2017 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.
+
+#ifndef COMPONENTS_SYNC_USER_EVENTS_USER_EVENT_SERVICE_H_
+#define COMPONENTS_SYNC_USER_EVENTS_USER_EVENT_SERVICE_H_
+
+#include <memory>
+
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "components/keyed_service/core/keyed_service.h"
+
+namespace sync_pb {
+class UserEventSpecifics;
+}  // namespace sync_pb
+
+namespace syncer {
+
+class ModelTypeSyncBridge;
+class SyncService;
+class UserEventSyncBridge;
+
+class UserEventService : public KeyedService {
+ public:
+  UserEventService(SyncService* sync_service,
+                   std::unique_ptr<UserEventSyncBridge> bridge);
+
+  ~UserEventService() override;
+
+  // KeyedService implementation
+  void Shutdown() override;
+
+  // Records a given event to be reported. Relevant settings will be checked to
+  // verify user events should be emitted and this will no-op if the the
+  // requisite permissions are not present.
+  void RecordUserEvent(std::unique_ptr<sync_pb::UserEventSpecifics> specifics);

[Patrick Noland, 2017/05/08 22:42:37]

Is there no way to tell(as a consumer of this service) if an event can be
recorded? Will they keep trying to record events even if they won't be recorded?
If so, is that what we want?

[skym, 2017/05/08 23:35:27]

Well, we could certainly add it. Would be easy to switch CanRecordEvent() to be
public. But if you put yourself in the shoes of a consumer, do you want to
bother checking? It'd certainly be easier to just blindly write, yeah?

[Patrick Noland, 2017/05/08 23:41:29]

It would be easier to blindly write, and it's probably relatively cheap to do
so, but maybe they'd be able to avoid some more expensive operation of their if
they knew that it was pointless? I'm just speculating; I wouldn't bother
changing it until you see a real world consumer that needs it. 

+  void RecordUserEvent(const sync_pb::UserEventSpecifics& specifics);
+
+  base::WeakPtr<ModelTypeSyncBridge> GetSyncBridge();
+
+ private:
+  bool CanRecordEvent(const sync_pb::UserEventSpecifics& specifics);
+
+  SyncService* sync_service_;
+
+  std::unique_ptr<UserEventSyncBridge> bridge_;
+
+  // Holds onto a random number for the duration of this execution of chrome. On
+  // restart it will be regenerated. This can be attached to events to know
+  // which events came from the same session.
+  uint64_t session_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(UserEventService);
+};
+
+}  // namespace syncer
+
+#endif  // COMPONENTS_SYNC_USER_EVENTS_USER_EVENT_SERVICE_H_