arc: enable use_new_wrapper_types for intent_helper.mojom

components/arc/intent_helper/activity_icon_loader.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/activity_icon_loader.h"
 
 #include <string.h>
 
 #include <tuple>
 #include <utility>
@@ skipping 50 matching lines @@
       it = cached_icons_.erase(it);
     else
       ++it;
   }
 }
 
 ActivityIconLoader::GetResult ActivityIconLoader::GetActivityIcons(
     const std::vector<ActivityName>& activities,
     const OnIconsReadyCallback& cb) {
   std::unique_ptr<ActivityToIconsMap> result(new ActivityToIconsMap);
-  mojo::Array<mojom::ActivityNamePtr> activities_to_fetch;
+  std::vector<mojom::ActivityNamePtr> activities_to_fetch;
 
   for (const auto& activity : activities) {
     const auto& it = cached_icons_.find(activity);
     if (it == cached_icons_.end()) {
       mojom::ActivityNamePtr name(mojom::ActivityName::New());
       name->package_name = activity.package_name;
       name->activity_name = activity.activity_name;
       activities_to_fetch.push_back(std::move(name));
     } else {
       result->insert(std::make_pair(activity, it->second));
@@ skipping 50 matching lines @@
     case GetResult::FAILED_ARC_NOT_READY:
     case GetResult::FAILED_ARC_NOT_SUPPORTED:
       break;
   }
   return true;
 }
 
 void ActivityIconLoader::OnIconsReady(
     std::unique_ptr<ActivityToIconsMap> cached_result,
     const OnIconsReadyCallback& cb,
-    mojo::Array<mojom::ActivityIconPtr> icons) {
+    std::vector<mojom::ActivityIconPtr> icons) {
   ArcServiceManager* manager = ArcServiceManager::Get();
   base::PostTaskAndReplyWithResult(
       manager->blocking_task_runner().get(), FROM_HERE,
       base::Bind(&ActivityIconLoader::ResizeIcons, this, base::Passed(&icons)),
       base::Bind(&ActivityIconLoader::OnIconsResized, this,
                  base::Passed(&cached_result), cb));
 }
 
 std::unique_ptr<ActivityIconLoader::ActivityToIconsMap>
-ActivityIconLoader::ResizeIcons(mojo::Array<mojom::ActivityIconPtr> icons) {
+ActivityIconLoader::ResizeIcons(std::vector<mojom::ActivityIconPtr> icons) {
   // Runs only on the blocking pool.
   DCHECK(thread_checker_.CalledOnValidThread());
   std::unique_ptr<ActivityToIconsMap> result(new ActivityToIconsMap);
 
   for (size_t i = 0; i < icons.size(); ++i) {
     static const size_t kBytesPerPixel = 4;
     const mojom::ActivityIconPtr& icon = icons.at(i);
     if (icon->width > kMaxIconSizeInPx || icon->height > kMaxIconSizeInPx ||
         icon->width == 0 || icon->height == 0 ||
         icon->icon.size() != (icon->width * icon->height * kBytesPerPixel)) {
       continue;
     }
 
     SkBitmap bitmap;
     bitmap.allocPixels(SkImageInfo::MakeN32Premul(icon->width, icon->height));
     if (!bitmap.getPixels())
       continue;
     DCHECK_GE(bitmap.getSafeSize(), icon->icon.size());
     memcpy(bitmap.getPixels(), &icon->icon.front(), icon->icon.size());
 
     gfx::ImageSkia original(gfx::ImageSkia::CreateFrom1xBitmap(bitmap));
     // Resize the original icon to the sizes intent_helper needs.
     gfx::ImageSkia icon_large(gfx::ImageSkiaOperations::CreateResizedImage(
         original, skia::ImageOperations::RESIZE_BEST,
         gfx::Size(kLargeIconSizeInDip, kLargeIconSizeInDip)));
     gfx::ImageSkia icon_small(gfx::ImageSkiaOperations::CreateResizedImage(
         original, skia::ImageOperations::RESIZE_BEST,
         gfx::Size(kSmallIconSizeInDip, kSmallIconSizeInDip)));
 
-    result->insert(
-        std::make_pair(ActivityName(icon->activity->package_name,
-                                    icon->activity->activity_name),
-                       Icons(gfx::Image(icon_small), gfx::Image(icon_large))));
+    const std::string activity_name = icon->activity->activity_name.has_value()
+                                          ? (*icon->activity->activity_name)
+                                          : std::string();
+    result->insert(std::make_pair(
+        ActivityName(icon->activity->package_name, activity_name),
+        Icons(gfx::Image(icon_small), gfx::Image(icon_large))));
   }
 
   return result;
 }
 
 void ActivityIconLoader::OnIconsResized(
     std::unique_ptr<ActivityToIconsMap> cached_result,
     const OnIconsReadyCallback& cb,
     std::unique_ptr<ActivityToIconsMap> result) {
   // Update |cached_icons_|.
   for (const auto& kv : *result) {
     cached_icons_.erase(kv.first);
     cached_icons_.insert(std::make_pair(kv.first, kv.second));
   }
 
   // Merge the results that were obtained from cache before doing IPC.
   result->insert(cached_result->begin(), cached_result->end());
   cb.Run(std::move(result));
 }
 
 }  // namespace arc