Replace base::File wrapping with typemapping.

third_party/WebKit/Source/platform/text/hyphenation/HyphenationMinikin.cpp

 // 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 "platform/text/Hyphenation.h"
 
 #include "base/files/file.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/metrics/histogram.h"
 #include "base/timer/elapsed_timer.h"
-#include "mojo/public/cpp/system/platform_handle.h"
 #include "platform/LayoutLocale.h"
 #include "platform/text/hyphenation/HyphenatorAOSP.h"
 #include "public/platform/InterfaceProvider.h"
 #include "public/platform/Platform.h"
 #include "public/platform/modules/hyphenation/hyphenation.mojom-blink.h"
 
 namespace blink {
 
 using Hyphenator = android::Hyphenator;
 
 class HyphenationMinikin : public Hyphenation {
  public:
   bool openDictionary(const AtomicString& locale);
 
   size_t lastHyphenLocation(const StringView& text,
                             size_t beforeIndex) const override;
   Vector<size_t, 8> hyphenLocations(const StringView&) const override;
 
  private:
-  static base::PlatformFile openDictionaryFile(const AtomicString& locale);
+  static base::File openDictionaryFile(const AtomicString& locale);
 
   std::vector<uint8_t> hyphenate(const StringView&) const;
 
   base::MemoryMappedFile m_file;
   std::unique_ptr<Hyphenator> m_hyphenator;
 };
 
 static mojom::blink::HyphenationPtr connectToRemoteService() {
   mojom::blink::HyphenationPtr service;
   Platform::current()->interfaceProvider()->getInterface(
       mojo::GetProxy(&service));
   return service;
 }
 
 static const mojom::blink::HyphenationPtr& getService() {
   DEFINE_STATIC_LOCAL(mojom::blink::HyphenationPtr, service,
                       (connectToRemoteService()));
   return service;
 }
 
-base::PlatformFile HyphenationMinikin::openDictionaryFile(
-    const AtomicString& locale) {
+base::File HyphenationMinikin::openDictionaryFile(const AtomicString& locale) {
   const mojom::blink::HyphenationPtr& service = getService();
-  mojo::ScopedHandle handle;
+  base::File file;
   base::ElapsedTimer timer;
-  service->OpenDictionary(locale, &handle);
+  service->OpenDictionary(locale, &file);
   UMA_HISTOGRAM_TIMES("Hyphenation.Open", timer.Elapsed());
-  if (!handle.is_valid())
-    return base::kInvalidPlatformFile;
-
-  base::PlatformFile file;
-  MojoResult result = mojo::UnwrapPlatformFile(std::move(handle), &file);
-  if (result != MOJO_RESULT_OK) {
-    DLOG(ERROR) << "UnwrapPlatformFile failed";
-    return base::kInvalidPlatformFile;
-  }
   return file;
 }
 
 bool HyphenationMinikin::openDictionary(const AtomicString& locale) {
-  base::PlatformFile file = openDictionaryFile(locale);
-  if (file == base::kInvalidPlatformFile)
+  base::File file = openDictionaryFile(locale);
+  if (!file.IsValid())
     return false;
-  if (!m_file.Initialize(base::File(file))) {
+  if (!m_file.Initialize(std::move(file))) {
     DLOG(ERROR) << "mmap failed";
     return false;
   }
 
   m_hyphenator = wrapUnique(Hyphenator::loadBinary(m_file.data()));
 
   return true;
 }
 
 std::vector<uint8_t> HyphenationMinikin::hyphenate(
@@ skipping 89 matching lines @@
 
   DEFINE_STATIC_LOCAL(LocaleMap, localeFallback, (createLocaleFallbackMap()));
   const auto& it = localeFallback.find(locale);
   if (it != localeFallback.end())
     return LayoutLocale::get(it->value)->getHyphenation();
 
   return nullptr;
 }
 
 }  // namespace blink