Add the JNI code in order to let Java use the InterestsFetcher.

chrome/browser/interests/interests_fetcher.cc

 // Copyright 2015 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/interests/interests_fetcher.h"
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
@@ skipping 13 matching lines @@
 const int kNumRetries = 1;
 const char kIdInterests[] = "interests";
 const char kIdInterestName[] = "name";
 const char kIdInterestImageUrl[] = "imageUrl";
 const char kIdInterestRelevance[] = "relevance";
 
 const char kApiScope[] = "https://www.googleapis.com/auth/googlenow";
 
 const char kAuthorizationHeaderFormat[] = "Authorization: Bearer %s";
 
-std::vector<InterestsFetcher::Interest> EmptyResponse() {
-  return std::vector<InterestsFetcher::Interest>();
-}
-
 GURL GetInterestsURL() {
   const base::CommandLine* command_line =
       base::CommandLine::ForCurrentProcess();
   return GURL(command_line->GetSwitchValueASCII(switches::kInterestsURL));
 }
 
 }  // namespace
 
 InterestsFetcher::Interest::Interest(const std::string& name,
                                      const GURL& image_url,
@@ skipping 38 matching lines @@
     const InterestsFetcher::InterestsCallback& callback) {
   DCHECK(callback_.is_null());
   callback_ = callback;
   StartOAuth2Request();
 }
 
 void InterestsFetcher::OnURLFetchComplete(const net::URLFetcher* source) {
   const net::URLRequestStatus& status = source->GetStatus();
   if (!status.is_success()) {
     VLOG(2) << "Network error " << status.error();
-    callback_.Run(EmptyResponse());
+    callback_.Run(nullptr);
     return;
   }
 
   int response_code = source->GetResponseCode();
   // If we get an authorization error, refresh token and retry once.
   if (response_code == net::HTTP_UNAUTHORIZED && !access_token_expired_) {
     access_token_expired_ = true;
     token_service_->InvalidateAccessToken(account_id_,
                                           GetApiScopes(),
                                           access_token_);
     StartOAuth2Request();
     return;
   }
 
   if (response_code != net::HTTP_OK) {
     VLOG(2) << "HTTP error " << response_code;
-    callback_.Run(EmptyResponse());
+    callback_.Run(nullptr);
     return;
   }
 
   std::string response_body;
   source->GetResponseAsString(&response_body);
 
   callback_.Run(ExtractInterests(response_body));
 }
 
 void InterestsFetcher::OnGetTokenSuccess(
@@ skipping 12 matching lines @@
       base::StringPrintf(kAuthorizationHeaderFormat, access_token_.c_str()));
 
   fetcher_->Start();
 }
 
 void InterestsFetcher::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
   DLOG(WARNING) << error.ToString();
 
-  callback_.Run(EmptyResponse());
+  callback_.Run(nullptr);
 }
 
 void InterestsFetcher::StartOAuth2Request() {
   oauth_request_ =
       token_service_->StartRequest(account_id_, GetApiScopes(), this);
 }
 
 OAuth2TokenService::ScopeSet InterestsFetcher::GetApiScopes() {
   OAuth2TokenService::ScopeSet scopes;
   scopes.insert(kApiScope);
   return scopes;
 }
 
 scoped_ptr<net::URLFetcher> InterestsFetcher::CreateFetcher() {
   return
       net::URLFetcher::Create(0, GetInterestsURL(), net::URLFetcher::GET, this);
 }
 
-std::vector<InterestsFetcher::Interest> InterestsFetcher::ExtractInterests(
-    const std::string& response) {
+scoped_ptr<std::vector<InterestsFetcher::Interest>>
+InterestsFetcher::ExtractInterests(const std::string& response) {
   scoped_ptr<base::Value> value = base::JSONReader::Read(response);
   DVLOG(2) << response;
 
   const base::DictionaryValue* dict = nullptr;
   if (!value || !value->GetAsDictionary(&dict)) {
     DLOG(WARNING) << "Failed to parse global dictionary.";
-    return EmptyResponse();
+    return nullptr;
   }
 
   const base::ListValue* interests_list = nullptr;
   if (!dict->GetList(kIdInterests, &interests_list)) {
     DLOG(WARNING) << "Failed to parse interests list.";
-    return EmptyResponse();
+    return nullptr;
   }
 
-  std::vector<Interest> res;
+  scoped_ptr<std::vector<Interest>> res(new std::vector<Interest>());
   for (const base::Value* entry : *interests_list) {
     const base::DictionaryValue* interest_dict = nullptr;
     if (!entry->GetAsDictionary(&interest_dict)) {
       DLOG(WARNING) << "Failed to parse interest dictionary.";
       continue;
     }
 
     // Extract the parts of the interest.
     std::string name;
     std::string image_url;
     double relevance = 0;
 
     if (!interest_dict->GetString(kIdInterestName, &name)) {
       DLOG(WARNING) << "Failed to parse interest name.";
       continue;
     }
 
     if (!interest_dict->GetString(kIdInterestImageUrl, &image_url)) {
       DLOG(WARNING) << "Failed to parse interest image URL.";
       // image_url is not mandatory, however warn if omitted.
     }
 
     if (!interest_dict->GetDouble(kIdInterestRelevance, &relevance)) {
       DLOG(WARNING) << "Failed to parse interest relevance.";
       continue;
     }
 
-    res.push_back(Interest{name, GURL(image_url), relevance});
+    res->push_back(Interest{name, GURL(image_url), relevance});
   }
 
   return res;
 }