Fix segfault in PpdProvider

chromeos/printing/ppd_provider.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 "chromeos/printing/ppd_provider.h"
 
 #include <utility>
 
 #include "base/files/file_util.h"
 #include "base/json/json_parser.h"
@@ skipping 67 matching lines @@
   void Resolve(const Printer::PpdReference& ppd_reference,
                const PpdProvider::ResolveCallback& cb) override {
     CHECK(!cb.is_null());
     CHECK(resolve_sequence_checker_.CalledOnValidSequence());
     CHECK(base::SequencedTaskRunnerHandle::IsSet())
         << "Resolve must be called from a SequencedTaskRunner context";
     CHECK(!resolve_inflight_)
         << "Can't have concurrent PpdProvider Resolve calls";
     resolve_inflight_ = true;
     auto cache_result = base::MakeUnique<base::Optional<base::FilePath>>();
+    auto* raw_cache_result_ptr = cache_result.get();
     bool post_result = io_task_runner_->PostTaskAndReply(
         FROM_HERE, base::Bind(&PpdProviderImpl::ResolveDoCacheLookup,
                               weak_factory_.GetWeakPtr(), ppd_reference,
-                              cache_result.get()),
+                              raw_cache_result_ptr),
         base::Bind(&PpdProviderImpl::ResolveCacheLookupDone,
                    weak_factory_.GetWeakPtr(), ppd_reference, cb,
                    std::move(cache_result)));
     DCHECK(post_result);
   }
 
   void QueryAvailable(const QueryAvailableCallback& cb) override {
     CHECK(!cb.is_null());
     CHECK(base::SequencedTaskRunnerHandle::IsSet())
         << "QueryAvailable() must be called from a SequencedTaskRunner context";
     auto cache_result = base::MakeUnique<
         base::Optional<const PpdProvider::AvailablePrintersMap*>>();
     CHECK(!query_inflight_)
         << "Can't have concurrent PpdProvider QueryAvailable calls";
     query_inflight_ = true;
+    auto* raw_cache_result_ptr = cache_result.get();
     CHECK(io_task_runner_->PostTaskAndReply(
         FROM_HERE, base::Bind(&PpdProviderImpl::QueryAvailableDoCacheLookup,
-                              weak_factory_.GetWeakPtr(), cache_result.get()),
+                              weak_factory_.GetWeakPtr(), raw_cache_result_ptr),
         base::Bind(&PpdProviderImpl::QueryAvailableCacheLookupDone,
                    weak_factory_.GetWeakPtr(), cb, std::move(cache_result))));
   }
 
   bool CachePpd(const Printer::PpdReference& ppd_reference,
                 const base::FilePath& ppd_path) override {
     std::string buf;
     if (!base::ReadFileToStringWithMaxSize(ppd_path, &buf,
                                            options_.max_ppd_contents_size_)) {
       return false;
     }
     return static_cast<bool>(cache_->Store(ppd_reference, buf));
   }
 
  private:
   // Trivial wrappers around PpdCache::Find() and
   // PpdCache::FindAvailablePrinters().  We need these wrappers both because we
   // use weak_ptrs to manage lifetime, and so we need to bind callbacks to
   // *this*, and because weak_ptr's preclude return values in posted tasks, so
   // we have to use a parameter to return state.
   void ResolveDoCacheLookup(
       const Printer::PpdReference& reference,
       base::Optional<base::FilePath>* cache_result) const {
     *cache_result = cache_->Find(reference);
   }
 
   void QueryAvailableDoCacheLookup(
       base::Optional<const PpdProvider::AvailablePrintersMap*>* cache_result)
       const {
+    DCHECK(cache_result);
     auto tmp = cache_->FindAvailablePrinters();
     if (tmp != nullptr) {
       *cache_result = tmp;
     } else {
       *cache_result = base::nullopt;
     }
   }
 
   // Callback that happens when the Resolve() cache lookup completes.  If the
   // cache satisfied the request, finish the Resolve, otherwise start a URL
@@ skipping 267 matching lines @@
     scoped_refptr<net::URLRequestContextGetter> url_context_getter,
     scoped_refptr<base::SequencedTaskRunner> io_task_runner,
     std::unique_ptr<PpdCache> cache,
     const PpdProvider::Options& options) {
   return base::MakeUnique<PpdProviderImpl>(
       api_key, url_context_getter, io_task_runner, std::move(cache), options);
 }
 
 }  // namespace printing
 }  // namespace chromeos