Context Menus now uses the JSON Schema Compiler.

chrome/browser/extensions/menu_manager_unittest.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 <vector>
 
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
@@ skipping 172 matching lines @@
   ASSERT_EQ(1u, manager_.MenuItems(item2->extension_id())->size());
   ASSERT_EQ(item2, manager_.MenuItems(item2->extension_id())->at(0));
 
   // Remove child2_item.
   ASSERT_TRUE(manager_.RemoveContextMenuItem(id2_child));
   ASSERT_EQ(1u, manager_.MenuItems(item2->extension_id())->size());
   ASSERT_EQ(item2, manager_.MenuItems(item2->extension_id())->at(0));
   ASSERT_EQ(0, item2->child_count());
 }
 
+TEST_F(MenuManagerTest, PopulateFromValue) {
+  Extension* extension = AddExtension("test");
+
+  bool incognito = true;
+  int type = MenuItem::CHECKBOX;
+  std::string title("TITLE");
+  bool checked = true;
+  bool enabled = true;
+  MenuItem::ContextList contexts;
+  contexts.Add(MenuItem::PAGE);
+  contexts.Add(MenuItem::SELECTION);
+  int contexts_value = 0;
+  ASSERT_TRUE(contexts.ToValue()->GetAsInteger(&contexts_value));
+
+  ListValue* document_url_patterns(new ListValue());
+  document_url_patterns->Append(
+      Value::CreateStringValue("http://www.google.com/*"));
+  document_url_patterns->Append(
+      Value::CreateStringValue("http://www.reddit.com/*"));
+
+  ListValue* target_url_patterns(new ListValue());
+  target_url_patterns->Append(
+      Value::CreateStringValue("http://www.yahoo.com/*"));
+  target_url_patterns->Append(
+      Value::CreateStringValue("http://www.facebook.com/*"));
+
+  base::DictionaryValue value;
+  value.SetBoolean("incognito", incognito);
+  value.SetString("string_uid", std::string());
+  value.SetInteger("type", type);
+  value.SetString("title", title);
+  value.SetBoolean("checked", checked);
+  value.SetBoolean("enabled", enabled);
+  value.SetInteger("contexts", contexts_value);
+  value.Set("document_url_patterns", document_url_patterns);
+  value.Set("target_url_patterns", target_url_patterns);
+
+  std::string error;
+  scoped_ptr<MenuItem> item(MenuItem::Populate(extension->id(), value, &error));
+  ASSERT_TRUE(item.get());
+
+  EXPECT_EQ(extension->id(), item->extension_id());
+  EXPECT_EQ(incognito, item->incognito());
+  EXPECT_EQ(title, item->title());
+  EXPECT_EQ(checked, item->checked());
+  EXPECT_EQ(item->checked(), item->checked());
+  EXPECT_EQ(enabled, item->enabled());
+  EXPECT_EQ(contexts, item->contexts());
+
+  URLPatternSet document_url_pattern_set;
+  document_url_pattern_set.Populate(*document_url_patterns,
+                                    URLPattern::SCHEME_ALL,
+                                    true,
+                                    &error);
+  EXPECT_EQ(document_url_pattern_set, item->document_url_patterns());
+
+  URLPatternSet target_url_pattern_set;
+  target_url_pattern_set.Populate(*target_url_patterns,
+                                   URLPattern::SCHEME_ALL,
+                                   true,
+                                   &error);
+  EXPECT_EQ(target_url_pattern_set, item->target_url_patterns());
+}
+
 // Tests that deleting a parent properly removes descendants.
 TEST_F(MenuManagerTest, DeleteParent) {
   Extension* extension = AddExtension("1111");
 
   // Set up 5 items to add.
   MenuItem* item1 = CreateTestItem(extension);
   MenuItem* item2 = CreateTestItem(extension);
   MenuItem* item3 = CreateTestItemWithID(extension, "id3");
   MenuItem* item4 = CreateTestItemWithID(extension, "id4");
   MenuItem* item5 = CreateTestItem(extension);
@@ skipping 169 matching lines @@
 
 // A mock message service for tests of MenuManager::ExecuteCommand.
 class MockEventRouter : public EventRouter {
  public:
   explicit MockEventRouter(Profile* profile) :
       EventRouter(profile) {}
 
   MOCK_METHOD6(DispatchEventToExtensionMock,
                void(const std::string& extension_id,
                     const std::string& event_name,
                     base::ListValue* event_args,

[not at google - send to devlin, 2012/08/14 05:12:21]

I don't know how mocks are supposed to work, but I'm surprised to see this as
base::ListValue* rather than scoped_ptr<ListValue>.

[chebert, 2012/08/14 18:56:53]

I think that this is a mock specific thing, since the "DispatchEventToExtension"
takes a scoped_ptr<ListValue> and  releases it to this method.

On 2012/08/14 05:12:21, kalman wrote:

                     Profile* source_profile,
                     const GURL& event_url,
                     EventRouter::UserGestureState state));
 
   virtual void DispatchEventToExtension(const std::string& extension_id,
                                         const std::string& event_name,
                                         scoped_ptr<base::ListValue> event_args,
                                         Profile* source_profile,
                                         const GURL& event_url,
                                         EventRouter::UserGestureState state) {
@@ skipping 135 matching lines @@
   ASSERT_EQ(params.page_url.spec(), tmp);
 
   string16 tmp16;
   ASSERT_TRUE(info->GetString("selectionText", &tmp16));
   ASSERT_EQ(params.selection_text, tmp16);
 
   bool bool_tmp = true;
   ASSERT_TRUE(info->GetBoolean("editable", &bool_tmp));
   ASSERT_EQ(params.is_editable, bool_tmp);
 
   delete list;

[not at google - send to devlin, 2012/08/14 05:12:21]

make list a scoped_ptr so that you don't need to call delete.

[chebert, 2012/08/14 18:56:53]

This is another mock specific thing.
The address of the list pointer needs to be passed to the Mock for the
assertion.
Line 563:
.WillOnce(SaveArg<2>(&list));

On 2012/08/14 05:12:21, kalman wrote:

[not at google - send to devlin, 2012/08/14 22:04:49]

You can't do

.WillOnce(SaveArg<2>(list.get())) there, if list is a scoped ptr?

[chebert, 2012/08/14 22:06:49]

it would need to be
.WillOnce(SaveArg<2>(&(list.get()))
and you can't get the address of an RValue.

On 2012/08/14 22:04:49, kalman wrote:

 }
 
 // Test that there is always only one radio item selected.
 TEST_F(MenuManagerTest, SanitizeRadioButtons) {
   Extension* extension = AddExtension("test");
 
   // A single unchecked item should get checked
   MenuItem* item1 = CreateTestItem(extension);
 
   item1->set_type(MenuItem::RADIO);
@@ skipping 74 matching lines @@
   ASSERT_TRUE(child1->checked());
 
   // Removing |parent| should cause only |child1| to be selected.
   manager_.RemoveContextMenuItem(parent->id());
   parent = NULL;
   ASSERT_FALSE(new_item->checked());
   ASSERT_TRUE(child1->checked());
 }
 
 }  // namespace extensions