Refactor away most of ExtensionRendererInfo

chrome/common/render_messages_params.cc

 // Copyright (c) 2010 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/common/render_messages_params.h"
 
 #include "chrome/common/navigation_gesture.h"
 #include "chrome/common/common_param_traits.h"
+#include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/render_messages.h"
 #include "net/base/upload_data.h"
 
 ViewMsg_Navigate_Params::ViewMsg_Navigate_Params()
     : page_id(-1),
       pending_history_list_offset(-1),
       current_history_list_offset(-1),
       current_history_list_length(0),
       transition(PageTransition::LINK),
       navigation_type(NORMAL) {
@@ skipping 222 matching lines @@
 ViewHostMsg_CreateWindow_Params::~ViewHostMsg_CreateWindow_Params() {
 }
 
 ViewHostMsg_RunFileChooser_Params::ViewHostMsg_RunFileChooser_Params()
     : mode(Open) {
 }
 
 ViewHostMsg_RunFileChooser_Params::~ViewHostMsg_RunFileChooser_Params() {
 }
 
-ViewMsg_ExtensionRendererInfo::ViewMsg_ExtensionRendererInfo()
-    : location(Extension::INVALID),
-      allowed_to_execute_script_everywhere(false) {
-}
-
-ViewMsg_ExtensionRendererInfo::~ViewMsg_ExtensionRendererInfo() {
-}
-
-ViewMsg_ExtensionsUpdated_Params::ViewMsg_ExtensionsUpdated_Params() {
-}
-
-ViewMsg_ExtensionsUpdated_Params::~ViewMsg_ExtensionsUpdated_Params() {
-}
-
 ViewMsg_DeviceOrientationUpdated_Params::
     ViewMsg_DeviceOrientationUpdated_Params()
     : can_provide_alpha(false),
       alpha(0),
       can_provide_beta(false),
       beta(0),
       can_provide_gamma(false),
       gamma(0) {
 }
 
 ViewMsg_DeviceOrientationUpdated_Params::
     ~ViewMsg_DeviceOrientationUpdated_Params() {
 }
 
 ViewHostMsg_DomMessage_Params::ViewHostMsg_DomMessage_Params()
     : request_id(0),
       has_callback(false),
       user_gesture(false) {
 }
 
 ViewHostMsg_DomMessage_Params::~ViewHostMsg_DomMessage_Params() {
 }
 
+ViewMsg_ExtensionLoaded_Params::ViewMsg_ExtensionLoaded_Params() {
+}
+
+ViewMsg_ExtensionLoaded_Params::ViewMsg_ExtensionLoaded_Params(
+    const ViewMsg_ExtensionLoaded_Params& other)
+    : manifest(other.manifest->DeepCopy()),
+      location(other.location),
+      path(other.path) {
+}
+
+ViewMsg_ExtensionLoaded_Params::ViewMsg_ExtensionLoaded_Params(
+    const Extension* extension) {
+  location = extension->location();
+  path = extension->path();
+  manifest.reset(new DictionaryValue());
+
+  // As we need more bits of extension data in the renderer, add more keys to
+  // this list.
+  const char* kRendererExtensionKeys[] = {
+    extension_manifest_keys::kPublicKey,
+    extension_manifest_keys::kName,
+    extension_manifest_keys::kVersion,
+    extension_manifest_keys::kIcons,
+    extension_manifest_keys::kPermissions,
+    extension_manifest_keys::kApp
+  };
+
+  // Copy only the data we need.
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRendererExtensionKeys); ++i) {
+    Value* temp = NULL;
+    if (extension->manifest_value()->Get(kRendererExtensionKeys[i], &temp))
+      manifest->Set(kRendererExtensionKeys[i], temp->DeepCopy());
+  }
+}
+
+scoped_refptr<Extension>
+    ViewMsg_ExtensionLoaded_Params::ConvertToExtension() const {
+  // Extensions that are loaded unpacked won't have a key.
+  const bool kRequireKey = false;
+  std::string error;
+
+  scoped_refptr<Extension> extension(
+      Extension::Create(path, location, *manifest, kRequireKey, &error));
+  if (!extension.get())
+    LOG(ERROR) << "Error deserializing extension: " << error;
+
+  return extension;
+}
+
 namespace IPC {
 
 // Self contained templates which are only used inside serializing Params
 // structs.
 template<>
 struct ParamTraits<ViewMsg_Navigate_Params::NavigationType> {
   typedef ViewMsg_Navigate_Params::NavigationType param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteInt(p);
   }
@@ skipping 1150 matching lines @@
     default:
       l->append("(UNKNOWN, ");
   }
   LogParam(p.title, l);
   l->append(", ");
   LogParam(p.default_file_name, l);
   l->append(", ");
   LogParam(p.accept_types, l);
 }
 
-void ParamTraits<ViewMsg_ExtensionRendererInfo>::Write(Message* m,
-                                                       const param_type& p) {
-  WriteParam(m, p.id);
-  WriteParam(m, p.web_extent);
-  WriteParam(m, p.name);
-  WriteParam(m, p.icon_url);
+void ParamTraits<ViewMsg_ExtensionLoaded_Params>::Write(Message* m,
+                                                        const param_type& p) {
   WriteParam(m, p.location);
-  WriteParam(m, p.allowed_to_execute_script_everywhere);
-  WriteParam(m, p.host_permissions);
+  WriteParam(m, p.path);
+  WriteParam(m, *(p.manifest));
 }
 
-bool ParamTraits<ViewMsg_ExtensionRendererInfo>::Read(const Message* m,
-                                                      void** iter,
-                                                      param_type* p) {
-  return ReadParam(m, iter, &p->id) &&
-      ReadParam(m, iter, &p->web_extent) &&
-      ReadParam(m, iter, &p->name) &&
-      ReadParam(m, iter, &p->icon_url) &&
-      ReadParam(m, iter, &p->location) &&
-      ReadParam(m, iter, &p->allowed_to_execute_script_everywhere) &&
-      ReadParam(m, iter, &p->host_permissions);
+bool ParamTraits<ViewMsg_ExtensionLoaded_Params>::Read(const Message* m,
+                                                       void** iter,
+                                                       param_type* p) {
+  p->manifest.reset(new DictionaryValue());
+  return ReadParam(m, iter, &p->location) &&
+         ReadParam(m, iter, &p->path) &&
+         ReadParam(m, iter, p->manifest.get());
 }
 
-void ParamTraits<ViewMsg_ExtensionRendererInfo>::Log(const param_type& p,
-                                                     std::string* l) {
-  LogParam(p.id, l);
-}
-
-void ParamTraits<ViewMsg_ExtensionsUpdated_Params>::Write(
-    Message* m,
-    const param_type& p) {
-  WriteParam(m, p.extensions);
-}
-
-bool ParamTraits<ViewMsg_ExtensionsUpdated_Params>::Read(
-    const Message* m,
-    void** iter,
-    param_type* p) {
-  return ReadParam(m, iter, &p->extensions);
-}
-
-void ParamTraits<ViewMsg_ExtensionsUpdated_Params>::Log(
-    const param_type& p,
-    std::string* l) {
-  LogParam(p.extensions, l);
+void ParamTraits<ViewMsg_ExtensionLoaded_Params>::Log(const param_type& p,
+                                                      std::string* l) {
+  l->append("<ViewMsg_ExtensionLoaded_Params>");

[Matt Perry, 2011/01/24 20:08:34]

nit: might also put the extension ID here

[Aaron Boodman, 2011/01/25 00:27:33]

We do not have the ID handy, all we have is the key. I've modified the IPC
message to store the ID in addition, though it is only needed for this logging.

[Matt Perry, 2011/01/25 00:45:54]

In that case, I don't think it's really needed, just a nice to have. But if
you've already added it, may as well keep it.

 }
 
 void ParamTraits<ViewMsg_DeviceOrientationUpdated_Params>::Write(
     Message* m,
     const param_type& p) {
   WriteParam(m, p.can_provide_alpha);
   WriteParam(m, p.alpha);
   WriteParam(m, p.can_provide_beta);
   WriteParam(m, p.beta);
   WriteParam(m, p.can_provide_gamma);
@@ skipping 116 matching lines @@
     const param_type& p,
     std::string* l) {
   l->append("(");
   LogParam(p.notification_type, l);
   l->append(", ");
   LogParam(p.acc_obj, l);
   l->append(")");
 }
 
 }  // namespace IPC