[Sync] Add a simple UI to sync-internals to create UserEvents.

chrome/browser/ui/webui/sync_internals_message_handler.cc

 // Copyright 2014 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/ui/webui/sync_internals_message_handler.h"
 
+#include <stdint.h>
+
 #include <utility>
 #include <vector>
 
+#include "base/feature_list.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
+#include "chrome/browser/sync/user_event_service_factory.h"
 #include "chrome/common/channel_info.h"
 #include "components/browser_sync/profile_sync_service.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 #include "components/sync/base/weak_handle.h"
 #include "components/sync/driver/about_sync_util.h"
+#include "components/sync/driver/sync_driver_switches.h"
 #include "components/sync/driver/sync_service.h"
 #include "components/sync/engine/cycle/commit_counters.h"
 #include "components/sync/engine/cycle/status_counters.h"
 #include "components/sync/engine/cycle/update_counters.h"
 #include "components/sync/engine/events/protocol_event.h"
 #include "components/sync/js/js_event_details.h"
+#include "components/sync/protocol/sync.pb.h"
+#include "components/sync/user_events/user_event_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_ui.h"
 
+using base::Value;
 using browser_sync::ProfileSyncService;
 using syncer::JsEventDetails;
 using syncer::ModelTypeSet;
 using syncer::WeakHandle;
 
 namespace {
+
+// Converts the string at |index| in |list| to an int, defaulting to 0 on error.
+int64_t IndexToInt64(const base::ListValue* list, int index) {

[Patrick Noland, 2017/05/09 23:46:23]

From the name I'd expect this to convert an index, not the value in the list at
the index. Maybe something like StringAtIndexToInt64?

[skym, 2017/05/10 00:06:46]

Done.

+  std::string str;
+  if (list->GetString(index, &str)) {
+    int64_t integer = 0;
+    if (base::StringToInt64(str, &integer)) {
+      return integer;
+    }
+  }
+  return 0;

[Patrick Noland, 2017/05/09 23:46:23]

So if you fat-finger one of the inputs the value will just silently default to
0. Are you sure that's what you want? I'm not sure how much validation there is
for UserEvents, but I know that e.g. ChromeHistory protos won't be written at
the server level if their timestamp falls outside of an acceptable window. 

[skym, 2017/05/10 00:06:46]

I think feedback in the UI that they've entered a value that doesn't convert
nicely to an int would be a great improvement, but I think we should improve
iteratively, seem reasonable?

+}
+
 class UtilAboutSyncDataExtractor : public AboutSyncDataExtractor {
  public:
   std::unique_ptr<base::DictionaryValue> ConstructAboutInformation(
       syncer::SyncService* service,
       SigninManagerBase* signin) override {
     return syncer::sync_ui_util::ConstructAboutInformation(
         service, signin, chrome::GetChannel());
   }
 };
+
 }  //  namespace
 
 SyncInternalsMessageHandler::SyncInternalsMessageHandler()
     : SyncInternalsMessageHandler(
           base::MakeUnique<UtilAboutSyncDataExtractor>()) {}
 
 SyncInternalsMessageHandler::SyncInternalsMessageHandler(
     std::unique_ptr<AboutSyncDataExtractor> about_sync_data_extractor)
     : about_sync_data_extractor_(std::move(about_sync_data_extractor)),
       weak_ptr_factory_(this) {}
@@ skipping 33 matching lines @@
 
   web_ui()->RegisterMessageCallback(
       syncer::sync_ui_util::kRequestListOfTypes,
       base::Bind(&SyncInternalsMessageHandler::HandleRequestListOfTypes,
                  base::Unretained(this)));
 
   web_ui()->RegisterMessageCallback(
       syncer::sync_ui_util::kGetAllNodes,
       base::Bind(&SyncInternalsMessageHandler::HandleGetAllNodes,
                  base::Unretained(this)));
+
+  web_ui()->RegisterMessageCallback(
+      syncer::sync_ui_util::kRequestUserEventsVisibility,
+      base::Bind(
+          &SyncInternalsMessageHandler::HandleRequestUserEventsVisibility,
+          base::Unretained(this)));
+
+  web_ui()->RegisterMessageCallback(
+      syncer::sync_ui_util::kWriteUserEvent,
+      base::Bind(&SyncInternalsMessageHandler::HandleWriteUserEvent,
+                 base::Unretained(this)));
 }
 
 void SyncInternalsMessageHandler::HandleRegisterForEvents(
     const base::ListValue* args) {
   DCHECK(args->empty());
 
   // is_registered_ flag protects us from double-registering.  This could
   // happen on a page refresh, where the JavaScript gets re-run but the
   // message handler remains unchanged.
   ProfileSyncService* service = GetProfileSyncService();
@@ skipping 34 matching lines @@
   base::DictionaryValue event_details;
   std::unique_ptr<base::ListValue> type_list(new base::ListValue());
   ModelTypeSet protocol_types = syncer::ProtocolTypes();
   for (ModelTypeSet::Iterator it = protocol_types.First();
        it.Good(); it.Inc()) {
     type_list->AppendString(ModelTypeToString(it.Get()));
   }
   event_details.Set(syncer::sync_ui_util::kTypes, type_list.release());
   web_ui()->CallJavascriptFunctionUnsafe(
       syncer::sync_ui_util::kDispatchEvent,
-      base::Value(syncer::sync_ui_util::kOnReceivedListOfTypes), event_details);
+      Value(syncer::sync_ui_util::kOnReceivedListOfTypes), event_details);
 }
 
 void SyncInternalsMessageHandler::HandleGetAllNodes(
     const base::ListValue* args) {
   DCHECK_EQ(1U, args->GetSize());
   int request_id = 0;
   bool success = ExtractIntegerValue(args, &request_id);
   DCHECK(success);
 
   ProfileSyncService* service = GetProfileSyncService();
   if (service) {
     service->GetAllNodes(
         base::Bind(&SyncInternalsMessageHandler::OnReceivedAllNodes,
                    weak_ptr_factory_.GetWeakPtr(), request_id));
   }
 }
 
+void SyncInternalsMessageHandler::HandleRequestUserEventsVisibility(
+    const base::ListValue* args) {
+  DCHECK(args->empty());
+  web_ui()->CallJavascriptFunctionUnsafe(
+      syncer::sync_ui_util::kUserEventsVisibilityCallback,
+      Value(base::FeatureList::IsEnabled(switches::kSyncUserEvents)));
+}
+
+void SyncInternalsMessageHandler::HandleWriteUserEvent(
+    const base::ListValue* args) {
+  DCHECK_EQ(2U, args->GetSize());
+
+  Profile* profile = Profile::FromWebUI(web_ui());
+  syncer::UserEventService* user_event_service =
+      browser_sync::UserEventServiceFactory::GetForProfile(
+          profile->GetOriginalProfile());
+
+  sync_pb::UserEventSpecifics event_specifics;
+  event_specifics.set_event_time_usec(IndexToInt64(args, 0));
+  event_specifics.set_navigation_id(IndexToInt64(args, 1));
+  user_event_service->RecordUserEvent(event_specifics);
+}
+
 void SyncInternalsMessageHandler::OnReceivedAllNodes(
     int request_id,
     std::unique_ptr<base::ListValue> nodes) {
-  base::Value id(request_id);
+  Value id(request_id);
   web_ui()->CallJavascriptFunctionUnsafe(
       syncer::sync_ui_util::kGetAllNodesCallback, id, *nodes);
 }
 
 void SyncInternalsMessageHandler::OnStateChanged(syncer::SyncService* sync) {
   SendAboutInfo();
 }
 
 void SyncInternalsMessageHandler::OnProtocolEvent(
     const syncer::ProtocolEvent& event) {
   std::unique_ptr<base::DictionaryValue> value(
       syncer::ProtocolEvent::ToValue(event));
   web_ui()->CallJavascriptFunctionUnsafe(
       syncer::sync_ui_util::kDispatchEvent,
-      base::Value(syncer::sync_ui_util::kOnProtocolEvent), *value);
+      Value(syncer::sync_ui_util::kOnProtocolEvent), *value);
 }
 
 void SyncInternalsMessageHandler::OnCommitCountersUpdated(
     syncer::ModelType type,
     const syncer::CommitCounters& counters) {
   EmitCounterUpdate(type, syncer::sync_ui_util::kCommit, counters.ToValue());
 }
 
 void SyncInternalsMessageHandler::OnUpdateCountersUpdated(
     syncer::ModelType type,
@@ skipping 10 matching lines @@
 void SyncInternalsMessageHandler::EmitCounterUpdate(
     syncer::ModelType type,
     const std::string& counter_type,
     std::unique_ptr<base::DictionaryValue> value) {
   std::unique_ptr<base::DictionaryValue> details(new base::DictionaryValue());
   details->SetString(syncer::sync_ui_util::kModelType, ModelTypeToString(type));
   details->SetString(syncer::sync_ui_util::kCounterType, counter_type);
   details->Set(syncer::sync_ui_util::kCounters, value.release());
   web_ui()->CallJavascriptFunctionUnsafe(
       syncer::sync_ui_util::kDispatchEvent,
-      base::Value(syncer::sync_ui_util::kOnCountersUpdated), *details);
+      Value(syncer::sync_ui_util::kOnCountersUpdated), *details);
 }
 
 void SyncInternalsMessageHandler::HandleJsEvent(
     const std::string& name,
     const JsEventDetails& details) {
   DVLOG(1) << "Handling event: " << name
            << " with details " << details.ToString();
   web_ui()->CallJavascriptFunctionUnsafe(syncer::sync_ui_util::kDispatchEvent,
-                                         base::Value(name), details.Get());
+                                         Value(name), details.Get());
 }
 
 void SyncInternalsMessageHandler::SendAboutInfo() {
   ProfileSyncService* sync_service = GetProfileSyncService();
   SigninManagerBase* signin = sync_service ? sync_service->signin() : nullptr;
   std::unique_ptr<base::DictionaryValue> value =
       about_sync_data_extractor_->ConstructAboutInformation(sync_service,
                                                             signin);
   web_ui()->CallJavascriptFunctionUnsafe(
       syncer::sync_ui_util::kDispatchEvent,
-      base::Value(syncer::sync_ui_util::kOnAboutInfoUpdated), *value);
+      Value(syncer::sync_ui_util::kOnAboutInfoUpdated), *value);
 }
 
 // Gets the ProfileSyncService of the underlying original profile.
 // May return NULL (e.g., if sync is disabled on the command line).
 ProfileSyncService* SyncInternalsMessageHandler::GetProfileSyncService() {
   Profile* profile = Profile::FromWebUI(web_ui());
   return ProfileSyncServiceFactory::GetForProfile(
       profile->GetOriginalProfile());
 }