Revert of Stop passing raw pointers to base::Value API in c/b/chromeos and c/b/extensions

chrome/browser/extensions/api/omnibox/omnibox_api.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/api/omnibox/omnibox_api.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/common/extensions/api/omnibox.h"
 #include "chrome/common/extensions/api/omnibox/omnibox_handler.h"
 #include "components/search_engines/template_url.h"
 #include "components/search_engines/template_url_service.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 42 matching lines @@
     Profile* profile,
     const std::string& extension_id,
     const omnibox::DefaultSuggestResult& suggestion) {
   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile);
   if (!prefs)
     return false;
 
   std::unique_ptr<base::DictionaryValue> dict = suggestion.ToValue();
   // Add the content field so that the dictionary can be used to populate an
   // omnibox::SuggestResult.
-  dict->SetWithoutPathExpansion(
-      kSuggestionContent,
-      base::MakeUnique<base::Value>(base::Value::Type::STRING));
+  dict->SetWithoutPathExpansion(kSuggestionContent, new base::Value(""));
   prefs->UpdateExtensionPref(extension_id, kOmniboxDefaultSuggestion,
                              std::move(dict));
 
   return true;
 }
 
 // Returns a string used as a template URL string of the extension.
 std::string GetTemplateURLStringForExtension(const std::string& extension_id) {
   // This URL is not actually used for navigation. It holds the extension's ID.
   return std::string(extensions::kExtensionScheme) + "://" +
@@ skipping 16 matching lines @@
 // static
 bool ExtensionOmniboxEventRouter::OnInputChanged(
     Profile* profile, const std::string& extension_id,
     const std::string& input, int suggest_id) {
   EventRouter* event_router = EventRouter::Get(profile);
   if (!event_router->ExtensionHasEventListener(
           extension_id, omnibox::OnInputChanged::kEventName))
     return false;
 
   std::unique_ptr<base::ListValue> args(new base::ListValue());
-  args->Set(0, base::MakeUnique<base::Value>(input));
-  args->Set(1, base::MakeUnique<base::Value>(suggest_id));
+  args->Set(0, new base::Value(input));
+  args->Set(1, new base::Value(suggest_id));
 
   std::unique_ptr<Event> event = base::MakeUnique<Event>(
       events::OMNIBOX_ON_INPUT_CHANGED, omnibox::OnInputChanged::kEventName,
       std::move(args));
   event->restrict_to_browser_context = profile;
   event_router->DispatchEventToExtension(extension_id, std::move(event));
   return true;
 }
 
 // static
 void ExtensionOmniboxEventRouter::OnInputEntered(
     content::WebContents* web_contents,
     const std::string& extension_id,
     const std::string& input,
     WindowOpenDisposition disposition) {
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
 
   const Extension* extension =
       ExtensionRegistry::Get(profile)->enabled_extensions().GetByID(
           extension_id);
   CHECK(extension);
   extensions::TabHelper::FromWebContents(web_contents)->
       active_tab_permission_granter()->GrantIfRequested(extension);
 
   std::unique_ptr<base::ListValue> args(new base::ListValue());
-  args->Set(0, base::MakeUnique<base::Value>(input));
+  args->Set(0, new base::Value(input));
   if (disposition == WindowOpenDisposition::NEW_FOREGROUND_TAB)
-    args->Set(1, base::MakeUnique<base::Value>(kForegroundTabDisposition));
+    args->Set(1, new base::Value(kForegroundTabDisposition));
   else if (disposition == WindowOpenDisposition::NEW_BACKGROUND_TAB)
-    args->Set(1, base::MakeUnique<base::Value>(kBackgroundTabDisposition));
+    args->Set(1, new base::Value(kBackgroundTabDisposition));
   else
-    args->Set(1, base::MakeUnique<base::Value>(kCurrentTabDisposition));
+    args->Set(1, new base::Value(kCurrentTabDisposition));
 
   std::unique_ptr<Event> event = base::MakeUnique<Event>(
       events::OMNIBOX_ON_INPUT_ENTERED, omnibox::OnInputEntered::kEventName,
       std::move(args));
   event->restrict_to_browser_context = profile;
   EventRouter::Get(profile)
       ->DispatchEventToExtension(extension_id, std::move(event));
 
   content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_EXTENSION_OMNIBOX_INPUT_ENTERED,
@@ skipping 216 matching lines @@
     for (size_t i = 0; i < description_styles.size(); ++i) {
       if (description_styles[i].offset > placeholder)
         description_styles[i].offset += replacement.length() - 2;
     }
   }
 
   match->contents.assign(description);
 }
 
 }  // namespace extensions