arc: enable use_new_wrapper_types for intent_helper.mojom

components/arc/intent_helper/arc_intent_helper_bridge.cc

 // Copyright 2016 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 "components/arc/intent_helper/arc_intent_helper_bridge.h"
 
 #include <utility>
-#include <vector>
 
 #include "ash/common/shell_delegate.h"
 #include "ash/common/wallpaper/wallpaper_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/public/interfaces/new_window.mojom.h"
 #include "ash/shell.h"
 #include "base/command_line.h"
 #include "base/memory/weak_ptr.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/arc/intent_helper/activity_icon_loader.h"
@@ skipping 32 matching lines @@
       arc_bridge_service()->intent_helper()->GetInstanceForMethod("Init");
   DCHECK(instance);
   instance->Init(binding_.CreateInterfacePtrAndBind());
 }
 
 void ArcIntentHelperBridge::OnInstanceClosed() {
   DCHECK(thread_checker_.CalledOnValidThread());
   ash::Shell::GetInstance()->set_link_handler_model_factory(nullptr);
 }
 
-void ArcIntentHelperBridge::OnIconInvalidated(
-    const mojo::String& package_name) {
+void ArcIntentHelperBridge::OnIconInvalidated(const std::string& package_name) {
   DCHECK(thread_checker_.CalledOnValidThread());
   icon_loader_->InvalidateIcons(package_name);
 }
 
 void ArcIntentHelperBridge::OnOpenDownloads() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // TODO(607411): If the FileManager is not yet open this will open to
   // downloads by default, which is what we want.  However if it is open it will
   // simply be brought to the forgeground without forcibly being navigated to
   // downloads, which is probably not ideal.
   ash::WmShell::Get()->new_window_client()->OpenFileManager();
 }
 
-void ArcIntentHelperBridge::OnOpenUrl(const mojo::String& url) {
+void ArcIntentHelperBridge::OnOpenUrl(const std::string& url) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  GURL gurl(url.get());
-  ash::WmShell::Get()->delegate()->OpenUrlFromArc(gurl);
+  ash::WmShell::Get()->delegate()->OpenUrlFromArc(GURL(url));
 }
 
 void ArcIntentHelperBridge::OpenWallpaperPicker() {
   DCHECK(thread_checker_.CalledOnValidThread());
   ash::WmShell::Get()->wallpaper_controller()->OpenSetWallpaperPage();
 }
 
 void ArcIntentHelperBridge::SetWallpaperDeprecated(
-    mojo::Array<uint8_t> jpeg_data) {
+    const std::vector<uint8_t>& jpeg_data) {
   DCHECK(thread_checker_.CalledOnValidThread());
   LOG(ERROR) << "IntentHelper.SetWallpaper is deprecated";
 }
 
 std::unique_ptr<ash::LinkHandlerModel> ArcIntentHelperBridge::CreateModel(
     const GURL& url) {
   DCHECK(thread_checker_.CalledOnValidThread());
   std::unique_ptr<LinkHandlerModelImpl> impl(
       new LinkHandlerModelImpl(icon_loader_));
   if (!impl->Init(url))
     return nullptr;
   return std::move(impl);
 }
 
 // static
 bool ArcIntentHelperBridge::IsIntentHelperPackage(
     const std::string& package_name) {
   return package_name == kArcIntentHelperPackageName;
 }
 
 // static
-mojo::Array<mojom::IntentHandlerInfoPtr>
+std::vector<mojom::IntentHandlerInfoPtr>
 ArcIntentHelperBridge::FilterOutIntentHelper(
-    mojo::Array<mojom::IntentHandlerInfoPtr> handlers) {
-  mojo::Array<mojom::IntentHandlerInfoPtr> handlers_filtered;
+    std::vector<mojom::IntentHandlerInfoPtr> handlers) {
+  std::vector<mojom::IntentHandlerInfoPtr> handlers_filtered;
   for (auto& handler : handlers) {
-    if (IsIntentHelperPackage(handler->package_name.get()))
+    if (IsIntentHelperPackage(handler->package_name))
       continue;
     handlers_filtered.push_back(std::move(handler));
   }
   return handlers_filtered;
 }
 
 // static
 mojom::IntentHelperInstance*
 ArcIntentHelperBridge::GetIntentHelperInstanceWithErrorCode(
     const std::string& method_name_for_logging,
@@ skipping 32 matching lines @@
 
 // static
 mojom::IntentHelperInstance* ArcIntentHelperBridge::GetIntentHelperInstance(
     const std::string& method_name_for_logging,
     uint32_t min_instance_version) {
   return GetIntentHelperInstanceWithErrorCode(method_name_for_logging,
                                               min_instance_version, nullptr);
 }
 
 void ArcIntentHelperBridge::OnIntentFiltersUpdated(
-    mojo::Array<mojom::IntentFilterPtr> filters) {
+    std::vector<mojom::IntentFilterPtr> filters) {
   DCHECK(thread_checker_.CalledOnValidThread());
   activity_resolver_->UpdateIntentFilters(std::move(filters));
 }
 
 }  // namespace arc