Convert utility process extension Unpacker IPC to mojo

extensions/common/extension_messages.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 "extensions/common/extension_messages.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/memory/ptr_util.h"
 #include "content/public/common/common_param_traits.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_handler.h"
+#include "extensions/common/manifest_location_param_traits.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/permissions/permissions_info.h"
 
 using extensions::APIPermission;
 using extensions::APIPermissionInfo;
 using extensions::APIPermissionSet;
 using extensions::Extension;
 using extensions::Manifest;
 using extensions::ManifestHandler;
 using extensions::ManifestPermission;
@@ skipping 68 matching lines @@
     for (const auto& pair : tab_specific_permissions) {
       permissions_data->UpdateTabSpecificPermissions(
           pair.first, *pair.second.ToPermissionSet());
     }
   }
   return extension;
 }
 
 namespace IPC {
 
-template <>
-struct ParamTraits<Manifest::Location> {
-  typedef Manifest::Location param_type;
-  static void Write(base::Pickle* m, const param_type& p) {
-    int val = static_cast<int>(p);
-    WriteParam(m, val);
-  }
-  static bool Read(const base::Pickle* m,
-                   base::PickleIterator* iter,
-                   param_type* p) {
-    int val = 0;
-    if (!ReadParam(m, iter, &val) ||
-        val < Manifest::INVALID_LOCATION ||
-        val >= Manifest::NUM_LOCATIONS)
-      return false;
-    *p = static_cast<param_type>(val);
-    return true;
-  }
-  static void Log(const param_type& p, std::string* l) {
-    ParamTraits<int>::Log(static_cast<int>(p), l);
-  }
-};
-
 void ParamTraits<URLPattern>::GetSize(base::PickleSizer* s,
                                       const param_type& p) {
   GetParamSize(s, p.valid_schemes());
   GetParamSize(s, p.GetAsString());
 }
 
 void ParamTraits<URLPattern>::Write(base::Pickle* m, const param_type& p) {
   WriteParam(m, p.valid_schemes());
   WriteParam(m, p.GetAsString());
 }
@@ skipping 257 matching lines @@
          ReadParam(m, iter, &p->withheld_permissions) &&
          ReadParam(m, iter, &p->tab_specific_permissions);
 }
 
 void ParamTraits<ExtensionMsg_Loaded_Params>::Log(const param_type& p,
                                                   std::string* l) {
   l->append(p.id);
 }
 
 }  // namespace IPC