Sync the launch type pref for apps.

chrome/browser/extensions/app_sync_data.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/app_sync_data.h"
 
 #include "extensions/common/extension.h"
 #include "sync/api/sync_data.h"
 #include "sync/protocol/app_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 
 namespace extensions {
 
 AppSyncData::AppSyncData() {}
 
 AppSyncData::AppSyncData(const syncer::SyncData& sync_data) {
   PopulateFromSyncData(sync_data);
 }
 
 AppSyncData::AppSyncData(const syncer::SyncChange& sync_change) {
   PopulateFromSyncData(sync_change.sync_data());
   extension_sync_data_.set_uninstalled(
       sync_change.change_type() == syncer::SyncChange::ACTION_DELETE);
 }
 
 AppSyncData::AppSyncData(const Extension& extension,
                          bool enabled,
                          bool incognito_enabled,
                          const syncer::StringOrdinal& app_launch_ordinal,
-                         const syncer::StringOrdinal& page_ordinal)
+                         const syncer::StringOrdinal& page_ordinal,
+                         extensions::LaunchType launch_type)
     : extension_sync_data_(extension, enabled, incognito_enabled),
       app_launch_ordinal_(app_launch_ordinal),
-      page_ordinal_(page_ordinal) {
+      page_ordinal_(page_ordinal),
+      launch_type_(launch_type) {
 }
 
 AppSyncData::~AppSyncData() {}
 
 syncer::SyncData AppSyncData::GetSyncData() const {
   sync_pb::EntitySpecifics specifics;
   PopulateAppSpecifics(specifics.mutable_app());
 
   return syncer::SyncData::CreateLocalData(extension_sync_data_.id(),
                                    extension_sync_data_.name(),
                                    specifics);
 }
 
 syncer::SyncChange AppSyncData::GetSyncChange(
     syncer::SyncChange::SyncChangeType change_type) const {
   return syncer::SyncChange(FROM_HERE, change_type, GetSyncData());
 }
 
 void AppSyncData::PopulateAppSpecifics(sync_pb::AppSpecifics* specifics) const {
   DCHECK(specifics);
-  // Only sync the ordinal values if they are valid.
+  // Only sync the ordinal values and launch type if they are valid.
   if (app_launch_ordinal_.IsValid())
     specifics->set_app_launch_ordinal(app_launch_ordinal_.ToInternalValue());
   if (page_ordinal_.IsValid())
     specifics->set_page_ordinal(page_ordinal_.ToInternalValue());
 
+  if (launch_type_ >= extensions::LAUNCH_TYPE_FIRST &&
+      launch_type_ < extensions::NUM_LAUNCH_TYPES) {
+    specifics->set_launch_type(launch_type_);
+  }
+
   extension_sync_data_.PopulateExtensionSpecifics(
       specifics->mutable_extension());
 }
 
 void AppSyncData::PopulateFromAppSpecifics(
     const sync_pb::AppSpecifics& specifics) {
   extension_sync_data_.PopulateFromExtensionSpecifics(specifics.extension());
 
   app_launch_ordinal_ = syncer::StringOrdinal(specifics.app_launch_ordinal());
   page_ordinal_ = syncer::StringOrdinal(specifics.page_ordinal());
+
+  launch_type_ = specifics.has_launch_type()

[Nicolas Zea, 2013/12/18 21:14:04]

It might be worth considering what might happen if future versions introduce new
launch types. Not sure what the appropriate behavior should be in that case. I'm
guessing you'd want to preserve the "unknown" launch type, so that it isn't
overwritten.

[calamity, 2013/12/19 06:27:52]

Hmm yeah. We also wouldn't want to write an invalid value to the down-syncing
old client. I guess I could change the DCHECK in SetLaunchType to just ignore
invalid values for such a case?

[Nicolas Zea, 2013/12/19 19:57:00]

See my other comment. If we're introducing a mismatch between the local data and
the sync data, we need to be careful about how sync changes are triggered.

+      ? static_cast<extensions::LaunchType>(specifics.launch_type())
+      : LAUNCH_TYPE_INVALID;
 }
 
 void AppSyncData::PopulateFromSyncData(const syncer::SyncData& sync_data) {
   PopulateFromAppSpecifics(sync_data.GetSpecifics().app());
 }
 
 }  // namespace extensions