Home | History | Annotate | Download | only in enhanced_bookmarks 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "components/enhanced_bookmarks/bookmark_server_service.h"
      6 
      7 #include "base/auto_reset.h"
      8 #include "components/enhanced_bookmarks/enhanced_bookmark_model.h"
      9 #include "components/signin/core/browser/profile_oauth2_token_service.h"
     10 #include "components/signin/core/browser/signin_manager_base.h"
     11 #include "google_apis/gaia/gaia_constants.h"
     12 #include "net/base/load_flags.h"
     13 #include "net/url_request/url_request_context_getter.h"
     14 #include "ui/base/models/tree_node_iterator.h"
     15 
     16 namespace enhanced_bookmarks {
     17 
     18 BookmarkServerService::BookmarkServerService(
     19     scoped_refptr<net::URLRequestContextGetter> request_context_getter,
     20     ProfileOAuth2TokenService* token_service,
     21     SigninManagerBase* signin_manager,
     22     EnhancedBookmarkModel* enhanced_bookmark_model)
     23     : OAuth2TokenService::Consumer("bookmark_server_service"),
     24       model_(enhanced_bookmark_model),
     25       token_service_(token_service),
     26       signin_manager_(signin_manager),
     27       request_context_getter_(request_context_getter) {
     28   DCHECK(request_context_getter.get());
     29   DCHECK(token_service);
     30   DCHECK(signin_manager);
     31   DCHECK(enhanced_bookmark_model);
     32   model_->AddObserver(this);
     33 }
     34 
     35 BookmarkServerService::~BookmarkServerService() {
     36   model_->RemoveObserver(this);
     37 }
     38 
     39 void BookmarkServerService::AddObserver(
     40     BookmarkServerServiceObserver* observer) {
     41   observers_.AddObserver(observer);
     42 }
     43 
     44 void BookmarkServerService::RemoveObserver(
     45     BookmarkServerServiceObserver* observer) {
     46   observers_.RemoveObserver(observer);
     47 }
     48 
     49 const BookmarkNode* BookmarkServerService::BookmarkForRemoteId(
     50     const std::string& remote_id) const {
     51   std::map<std::string, const BookmarkNode*>::const_iterator it =
     52       starsid_to_bookmark_.find(remote_id);
     53   if (it == starsid_to_bookmark_.end())
     54     return NULL;
     55   return it->second;
     56 }
     57 
     58 const std::string BookmarkServerService::RemoteIDForBookmark(
     59     const BookmarkNode* bookmark) const {
     60   return model_->GetRemoteId(bookmark);
     61 }
     62 
     63 void BookmarkServerService::Notify() {
     64   FOR_EACH_OBSERVER(BookmarkServerServiceObserver, observers_, OnChange(this));
     65 }
     66 
     67 void BookmarkServerService::TriggerTokenRequest(bool cancel_previous) {
     68   if (cancel_previous)
     69     url_fetcher_.reset();
     70 
     71   if (token_request_ || url_fetcher_)
     72     return;  // Fetcher is already running.
     73 
     74   const std::string username(signin_manager_->GetAuthenticatedUsername());
     75   if (!username.length()) {
     76     // User is not signed in.
     77     CleanAfterFailure();
     78     Notify();
     79     return;
     80   }
     81   // Find a token.
     82   OAuth2TokenService::ScopeSet scopes;
     83   scopes.insert(GaiaConstants::kChromeSyncOAuth2Scope);
     84   token_request_ = token_service_->StartRequest(username, scopes, this);
     85 }
     86 
     87 //
     88 // OAuth2AccessTokenConsumer methods.
     89 //
     90 void BookmarkServerService::OnGetTokenSuccess(
     91     const OAuth2TokenService::Request* request,
     92     const std::string& access_token,
     93     const base::Time& expiration_time) {
     94   url_fetcher_.reset(CreateFetcher());
     95   // Free the token request.
     96   token_request_.reset();
     97 
     98   if (!url_fetcher_) {
     99     CleanAfterFailure();
    100     Notify();
    101     return;
    102   }
    103   url_fetcher_->SetRequestContext(request_context_getter_.get());
    104 
    105   // Add the token.
    106   std::string headers;
    107   headers = "Authorization: Bearer ";
    108   headers += access_token;
    109   headers += "\r\n";
    110   url_fetcher_->SetExtraRequestHeaders(headers);
    111 
    112   // Do not pollute the cookie store with cruft, or mix the users cookie in this
    113   // request.
    114   url_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
    115                              net::LOAD_DO_NOT_SAVE_COOKIES);
    116 
    117   url_fetcher_->Start();
    118 }
    119 
    120 void BookmarkServerService::OnGetTokenFailure(
    121     const OAuth2TokenService::Request* request,
    122     const GoogleServiceAuthError& error) {
    123   // Free the request.
    124   token_request_.reset();
    125   CleanAfterFailure();
    126   Notify();
    127 }
    128 
    129 //
    130 // net::URLFetcherDelegate methods.
    131 //
    132 void BookmarkServerService::OnURLFetchComplete(const net::URLFetcher* source) {
    133   scoped_ptr<net::URLFetcher> url_fetcher(url_fetcher_.Pass());
    134   std::string response;
    135   bool should_notify = true;
    136 
    137   if (url_fetcher->GetResponseCode() != 200 ||
    138       !url_fetcher->GetResponseAsString(&response) ||
    139       !ProcessResponse(response, &should_notify)) {
    140     CleanAfterFailure();
    141   }
    142   if (should_notify)
    143     Notify();
    144 }
    145 
    146 void BookmarkServerService::EnhancedBookmarkModelShuttingDown() {
    147   NOTREACHED();
    148 }
    149 
    150 SigninManagerBase* BookmarkServerService::GetSigninManager() {
    151   DCHECK(signin_manager_);
    152   return signin_manager_;
    153 }
    154 
    155 }  // namespace enhanced_bookmarks
    156