Add Desktop iOS promotion logging to chrome ios app.

ios/chrome/browser/desktop_promotion/desktop_promotion_sync_observer.h

Index: ios/chrome/browser/desktop_promotion/desktop_promotion_sync_observer.h
diff --git a/ios/chrome/browser/desktop_promotion/desktop_promotion_sync_observer.h b/ios/chrome/browser/desktop_promotion/desktop_promotion_sync_observer.h
new file mode 100644
index 0000000000000000000000000000000000000000..d6a993228cebe4b9c19f0ca5e0781627563a8b43
--- /dev/null
+++ b/ios/chrome/browser/desktop_promotion/desktop_promotion_sync_observer.h
@@ -0,0 +1,29 @@
+// 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 IOS_CHROME_BROWSER_SIGNIN_DESKTOP_PROMOTION_SYNC_OBSERVER_LOGGER_H_
+#define IOS_CHROME_BROWSER_SIGNIN_DESKTOP_PROMOTION_SYNC_OBSERVER_LOGGER_H_
+
+#include "base/macros.h"
+#include "components/sync/driver/sync_service_observer.h"
+
+namespace ios {
+class ChromeBrowserState;
+}
+
+class DesktopPromotionSyncObserver : public syncer::SyncServiceObserver {

[sdefresne, 2017/01/25 09:52:52]

If you want this observer to be created with the ChromeBrowserState, then you
can turn it into a KeyedService. Or maybe better have a factory that register a
private object owning the DesktopPromotionSyncObserver (to avoid multiple
inheritance).

You'll also have to include a call to
DesktopPromotionServiceFactory::GetInstance() in
EnsureBrowserStateKeyedServiceFactoriesBuilt() (see
browser_state_keyed_service_factories.mm). Once this is done, then you can
remove the instance of DesktopPromotionSyncObserver owned by the MainController.

Code for the factory and service would look like the following in the files
desktop_promotion_sync_service.{h,cc}:

// desktop_promotion_sync_service.h

namespace ios {
class ChromeBrowserState;
}

class DesktopPromotionSyncService;
class DesktopPromotionSyncServiceFactory : public
BrowserStateKeyedServiceFactory {
 public:
  static DesktopPromotionSyncService* GetForBrowserState(
      ios::ChromeBrowserState* browser_state);
  static DesktopPromotionSyncServiceFactory* GetInstance();

 private:
  friend struct
base::DefaultSingletonTraits<DesktopPromotionSyncServiceFactory>;

  HistoryServiceFactory();
  ~HistoryServiceFactory() override;

  // BrowserStateKeyedServiceFactory implementation.
  std::unique_ptr<KeyedService> BuildServiceInstanceFor(
      web::BrowserState* context) const override;
  bool ServiceIsCreatedWithBrowserState() const override;
  bool ServiceIsNULLWhileTesting() const override;

  // If you want the observer to be created for off-the-record browser states,
  // then you also need to override GetBrowserStateToUse() to return a non-null
  // browser state (either the off-the-record browser state or the regular one).

  DISALLOW_COPY_AND_ASSIGN(DesktopPromotionSyncServiceFactory);
};

// desktop_promotion_sync_service.cc

class DesktopPromotionSyncService : public KeyedService {
 public:
  DesktopPromotionSyncService(
      PrefService* pref_service,
      browser_sync::ProfileSyncService* sync_service);
  ~DekstopPromotionSyncService();

 private:
  DesktopPromotionSyncObserver observer_;
}

DesktopPromotionSyncService::DesktopPromotionSyncService(
    PrefService* pref_service,
    browser_sync::ProfileSyncService* sync_service)
    : observer_(pref_service, sync_service) {}

DesktopPromotionSyncService::~DesktopPromotionSyncService() = default;

// static
DesktopPromotionSyncService*
DesktopPromotionSyncServiceFactory::GetForBrowserState(
    ios::ChromeBrowserState* browser_state) {
  return static_cast<DesktopPromotionSyncService*>(
      GetInstance()->GetServiceForBrowserState(browser_state, true));
}

// static
DesktopPromotionSyncServiceFactory*
DesktopPromotionSyncServiceFactory::GetInstance() {
  return base::Singleton<DesktopPromotionSyncServiceFactory>::get();
}

DesktopPromotionSyncServiceFactory::DesktopPromotionSyncServiceFactory()
    : BrowserStateKeyedServiceFactory(
          "DesktopPromotionSyncService",
          BrowserStateDependencyManager::GetInstance()) {
  DependsOn(IOSChromeProfileSyncServiceFactory::GetInstance());
}

DesktopPromotionSyncServiceFactory::~DesktopPromotionSyncServiceFactory() =
default;

std::unique_ptr<KeyedService>
DesktopPromotionSyncServiceFactory::BuildServiceInstanceFor(
    web::BrowserState* context) const {
  ios::ChromeBrowserState* browser_state =
      ios::ChromeBrowserState::FromBrowserState(context);
  return base::MakeUnique<DesktopPromotionSyncService>(
    browser_state->GetPrefs(),
    IOSChromeProfileSyncServiceFactory::GetForBrowserState(browser_state));
}

// By returning true here, we for the keyed service system to create this object
when the
// chrome browser states are created.
bool DesktopPromotionSyncServiceFactory::ServiceIsCreatedWithBrowserState()
const {
  return true;
}

// I think that not creating the observer for testing browser state will make
thing much easier
// so I would recommend returning true here.
bool DesktopPromotionSyncServiceFactory::ServiceIsNULLWhileTesting() const {
  return true;
}

[mrefaat1, 2017/01/26 16:51:19]

Thanks for the advice, as per our discussion on hangout this service need to
wait for the browserstate so i moved the initialization to
browser_state_manager_impl.

+ public:
+  explicit DesktopPromotionSyncObserver(ios::ChromeBrowserState* browser_state);
+  ~DesktopPromotionSyncObserver() override;
+  // ProfileSyncServiceObserver implementation.
+  void OnStateChanged() override;
+
+ private:
+  ios::ChromeBrowserState* browser_state_;  // weak
+  bool desktop_metrics_logger_initiated_;
+
+  DISALLOW_COPY_AND_ASSIGN(DesktopPromotionSyncObserver);
+};
+
+#endif  // IOS_CHROME_BROWSER_SIGNIN_DESKTOP_PROMOTION_SYNC_OBSERVER_H_